vscode-ai-model-detector/src/index.ts

Real-time AI model detection with 100% accuracy using Chat Participant API

#!/usr/bin/env node

/**
 * AI Model De  constructor() {
    this.server = new Server(
      {
        name: 'ai-model-detector-mcp-server',
        version: '2.0.0',
      },
      {
        capabilities: {
          tools: {}
        }
      }
    );

    // Initialize real VS Code bridge for actual model detection
    this.bridge = new RealVSCodeBridge();er v2.0.0
 * 
 * Main server implementation using @modelcontextprotocol/sdk
 * Provides 4 MCP tools for AI model detection with 100% accuracy
 * through hybrid architecture bridging VS Code extension capabilities.
 */

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
  Tool
} from '@modelcontextprotocol/sdk/types.js';

import {
  DetectCurrentModelSchema,
  GetModelCapabilitiesSchema,
  MonitorModelChangesSchema,
  ValidateModelAccessSchema,
  RealVSCodeBridge,
  type VSCodeBridge,
  type ModelDetectionResult,
  type ModelDefinition
} from './types.js';

/**
 * AI Model Detector MCP Server
 * 
 * Exposes 4 tools for GitHub Copilot Agent mode integration:
 * 1. detect_current_model - Get currently selected AI model in real-time
 * 2. get_model_capabilities - Analyze capabilities of detected model
 * 3. monitor_model_changes - Real-time monitoring of model selection changes  
 * 4. validate_model_access - Verify model detection and connection status
 */
class AIModelDetectorServer {
  private server: Server;
  private bridge: VSCodeBridge;
  private monitoringSessions = new Map<string, string>();

  constructor() {
    this.server = new Server(
      {
        name: 'ai-model-detector-mcp-server',
        version: '2.0.0',
      },
      {
        capabilities: {
          tools: {},
        },
      }
    );

    // Initialize with real VS Code bridge for actual model detection
    this.bridge = new RealVSCodeBridge();

    this.setupHandlers();
  }

  private setupHandlers(): void {
    // List available tools
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      return {
        tools: [
          {
            name: 'detect_current_model',
            description: 'Get currently selected AI model in real-time with 100% accuracy',
            inputSchema: {
              type: 'object',
              properties: {
                requestId: {
                  type: 'string',
                  description: 'Optional request ID for tracking'
                }
              }
            }
          },
          {
            name: 'get_model_capabilities',
            description: 'Analyze capabilities and features of a specific AI model',
            inputSchema: {
              type: 'object',
              properties: {
                modelId: {
                  type: 'string',
                  description: 'Model ID to analyze capabilities for'
                }
              },
              required: ['modelId']
            }
          },
          {
            name: 'monitor_model_changes',
            description: 'Start real-time monitoring of AI model selection changes',
            inputSchema: {
              type: 'object',
              properties: {
                interval: {
                  type: 'number',
                  minimum: 1000,
                  default: 5000,
                  description: 'Monitoring interval in milliseconds (minimum 1000ms)'
                }
              }
            }
          },
          {
            name: 'validate_model_access',
            description: 'Verify AI model detection and connection status',
            inputSchema: {
              type: 'object',
              properties: {
                includeAvailableModels: {
                  type: 'boolean',
                  default: false,
                  description: 'Include list of all available models'
                }
              }
            }
          }
        ] as Tool[]
      };
    });

    // Handle tool execution
    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
      const { name, arguments: args } = request.params;

      try {
        switch (name) {
          case 'detect_current_model':
            return await this.handleDetectCurrentModel(args);
            
          case 'get_model_capabilities':
            return await this.handleGetModelCapabilities(args);
            
          case 'monitor_model_changes':
            return await this.handleMonitorModelChanges(args);
            
          case 'validate_model_access':
            return await this.handleValidateModelAccess(args);
            
          default:
            throw new Error(`Unknown tool: ${name}`);
        }
      } catch (error) {
        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
        return {
          content: [
            {
              type: 'text',
              text: `Error executing tool '${name}': ${errorMessage}`
            }
          ],
          isError: true
        };
      }
    });
  }

  /**
   * Tool: detect_current_model
   * Get currently selected AI model with 100% accuracy
   */
  private async handleDetectCurrentModel(args: any) {
    const parsed = DetectCurrentModelSchema.parse(args);
    const result = await this.bridge.detectCurrentModel();

    if (result.success && result.model) {
      return {
        content: [
          {
            type: 'text',
            text: `🎯 **Current AI Model Detected** (${result.model.accuracy} Accuracy)

**Model Information:**
- **ID**: ${result.model.id}
- **Name**: ${result.model.name}
- **Vendor**: ${result.model.vendor}
- **Family**: ${result.model.family}
- **Version**: ${result.model.version}
- **Max Tokens**: ${result.model.maxTokens.toLocaleString()}

**Detection Details:**
- **Method**: ${result.method}
- **Source**: ${result.model.source}
- **Timestamp**: ${result.model.timestamp?.toISOString() || new Date().toISOString()}
- **Duration**: ${result.performance?.duration || 0}ms
- **Request ID**: ${result.model.metadata?.requestId || 'auto-generated'}

**Status**: ✅ Successfully detected with breakthrough Chat Participant API accuracy`
          }
        ]
      };
    } else {
      return {
        content: [
          {
            type: 'text',
            text: `❌ **Model Detection Failed**

**Error**: ${result.error || 'Unknown detection error'}
**Method Attempted**: ${result.method}
**Duration**: ${result.performance?.duration || 0}ms

**Troubleshooting**: Ensure VS Code extension bridge is connected and Chat Participant API is available.`
          }
        ],
        isError: true
      };
    }
  }

  /**
   * Tool: get_model_capabilities
   * Analyze capabilities and features of a specific model
   */
  private async handleGetModelCapabilities(args: any) {
    const parsed = GetModelCapabilitiesSchema.parse(args);
    const capabilities = await this.bridge.getModelCapabilities(parsed.modelId);

    if (capabilities) {
      const capabilitiesList = capabilities.metadata?.capabilities || [];
      const specialFeatures = capabilities.metadata?.specialFeatures || [];
      
      return {
        content: [
          {
            type: 'text',
            text: `🔍 **Model Capabilities Analysis**

**Model**: ${capabilities.name} (${capabilities.id})

**Core Specifications:**
- **Vendor**: ${capabilities.vendor}
- **Family**: ${capabilities.family}
- **Version**: ${capabilities.version}
- **Context Window**: ${capabilities.maxTokens.toLocaleString()} tokens
- **Context Window Info**: ${capabilities.metadata?.contextWindow || 'Standard'}

**Capabilities**:
${capabilitiesList.length > 0 ? capabilitiesList.map((cap: string) => `- ${cap}`).join('\n') : '- Information not available'}

**Special Features**:
${specialFeatures.length > 0 ? specialFeatures.map((feature: string) => `- ${feature}`).join('\n') : '- No special features detected'}

**Performance Rating**: ${capabilities.accuracy}
**Last Updated**: ${capabilities.timestamp?.toISOString() || new Date().toISOString()}`
          }
        ]
      };
    } else {
      return {
        content: [
          {
            type: 'text',
            text: `❌ **Model Not Found**

**Searched Model ID**: ${parsed.modelId}

**Available Options**: Use 'validate_model_access' with includeAvailableModels=true to see all available models.`
          }
        ],
        isError: true
      };
    }
  }

  /**
   * Tool: monitor_model_changes
   * Start real-time monitoring of model selection changes
   */
  private async handleMonitorModelChanges(args: any) {
    const parsed = MonitorModelChangesSchema.parse(args);
    const sessionId = await this.bridge.startModelMonitoring(parsed.interval);
    
    this.monitoringSessions.set(sessionId, sessionId);

    return {
      content: [
        {
          type: 'text',
          text: `🔄 **Model Change Monitoring Started**

**Session ID**: ${sessionId}
**Monitoring Interval**: ${parsed.interval}ms (${(parsed.interval / 1000).toFixed(1)} seconds)
**Status**: Active

**Features**:
- Real-time model selection change detection
- Automatic logging to console
- VS Code extension bridge integration
- 100% accuracy through Chat Participant API

**To Stop Monitoring**: Use the session ID ${sessionId} with a stop monitoring command (available in future version).

**Note**: Monitor output appears in the MCP server console. Check your terminal for real-time model change notifications.`
        }
      ]
    };
  }

  /**
   * Tool: validate_model_access
   * Verify model detection and connection status
   */
  private async handleValidateModelAccess(args: any) {
    const parsed = ValidateModelAccessSchema.parse(args);
    const result = await this.bridge.validateModelAccess(parsed.includeAvailableModels);
    const isConnected = await this.bridge.isConnected();

    const availableModelsText = result.availableModels ? 
      result.availableModels.map((model: any) => 
        `- **${model.name}** (${model.id}) - ${model.vendor} - ${model.maxTokens.toLocaleString()} tokens`
      ).join('\n') : 'Available models not requested';

    return {
      content: [
        {
          type: 'text',
          text: `🏥 **Model Access Validation Report**

**Connection Status**: ${isConnected ? '✅ Connected' : '❌ Disconnected'}
**Validation Result**: ${result.success ? '✅ Success' : '❌ Failed'}
**Bridge Type**: VS Code Extension Bridge (${isConnected ? 'Active' : 'Inactive'})
**Validation Duration**: ${result.performance?.duration || 0}ms

**Active Monitoring Sessions**: ${this.monitoringSessions.size} session(s)

${parsed.includeAvailableModels ? `**Available Models**:\n${availableModelsText}` : '**Available Models**: Not requested (use includeAvailableModels=true)'}

**System Status**:
- MCP Server: ✅ Running
- Tool Registration: ✅ All 4 tools available
- VS Code Bridge: ${isConnected ? '✅ Connected' : '❌ Requires connection'}
- Chat Participant API: ${isConnected ? '✅ Available' : '⚠️ Checking...'}

**Troubleshooting**: ${isConnected ? 'All systems operational' : 'Check VS Code extension installation and activation'}`
        }
      ]
    };
  }

  /**
   * Start the MCP server
   */
  async run(): Promise<void> {
    const transport = new StdioServerTransport();
    await this.server.connect(transport);
    
    // Log startup information
    console.error('🚀 AI Model Detector MCP Server v2.0.0 started');
    console.error('📡 Connected via stdio transport');
    console.error('🔧 4 tools available: detect_current_model, get_model_capabilities, monitor_model_changes, validate_model_access');
    console.error('🎯 Hybrid architecture preserving 100% accuracy breakthrough');
    console.error('⚡ Ready for GitHub Copilot Agent mode integration');
  }
}

/**
 * Main execution
 */
async function main() {
  try {
    const server = new AIModelDetectorServer();
    await server.run();
  } catch (error) {
    console.error('❌ Failed to start AI Model Detector MCP Server:', error);
    process.exit(1);
  }
}

// Handle graceful shutdown
process.on('SIGINT', () => {
  console.error('\n👋 Shutting down AI Model Detector MCP Server...');
  process.exit(0);
});

process.on('SIGTERM', () => {
  console.error('\n👋 Shutting down AI Model Detector MCP Server...');
  process.exit(0);
});

// Start the server
if (import.meta.url === `file://${process.argv[1]}`) {
  main();
}