TypeScript MCP Sample Server

Implementation Reference

• src/index.ts:61-106 (handler)

  The asynchronous handler function implementing the 'completion' tool logic: validates model, emits events, generates mock response with usage stats, simulates delay, and returns text content.

  async ({ model, prompt, options }) => {
    console.log(`Processing completion request for model: ${model}`);
    
    // Validate model
    if (!this.models.includes(model)) {
      throw new Error(`Model ${model} not supported`);
    }
    
    // Emit event for monitoring/metrics
    this.events.emit('request', { 
      type: 'completion', 
      model, 
      timestamp: new Date() 
    });
    
    // In a real implementation, this would call an AI model
    // Here we just echo back parts of the request with a mock response
    const response = {
      id: `mcp-resp-${Date.now()}`,
      model,
      text: `This is a response to: ${prompt.substring(0, 30)}...`,
      usage: {
        promptTokens: prompt.split(' ').length,
        completionTokens: 20,
        totalTokens: prompt.split(' ').length + 20
      }
    };
    
    // Simulate network delay
    await new Promise(resolve => setTimeout(resolve, 500));
    
    // Emit completion event
    this.events.emit('completion', {
      model,
      timestamp: new Date()
    });
    
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(response)
        }
      ]
    };
  }

• src/index.ts:52-60 (schema)

  Zod schema defining input parameters for the 'completion' tool: required model and prompt strings, optional options object with temperature, max_tokens, and stream.

  {
    model: z.string(),
    prompt: z.string(),
    options: z.object({
      temperature: z.number().optional(),
      max_tokens: z.number().optional(),
      stream: z.boolean().optional()
    }).optional()
  },

• src/index.ts:49-108 (registration)

  The private method registering the 'completion' tool on the MCP server using mcpServer.tool(), including the tool name, input schema, and handler function.

  private registerCompletionTool(): void {
    this.mcpServer.tool(
      'completion',
      {
        model: z.string(),
        prompt: z.string(),
        options: z.object({
          temperature: z.number().optional(),
          max_tokens: z.number().optional(),
          stream: z.boolean().optional()
        }).optional()
      },
      async ({ model, prompt, options }) => {
        console.log(`Processing completion request for model: ${model}`);
        
        // Validate model
        if (!this.models.includes(model)) {
          throw new Error(`Model ${model} not supported`);
        }
        
        // Emit event for monitoring/metrics
        this.events.emit('request', { 
          type: 'completion', 
          model, 
          timestamp: new Date() 
        });
        
        // In a real implementation, this would call an AI model
        // Here we just echo back parts of the request with a mock response
        const response = {
          id: `mcp-resp-${Date.now()}`,
          model,
          text: `This is a response to: ${prompt.substring(0, 30)}...`,
          usage: {
            promptTokens: prompt.split(' ').length,
            completionTokens: 20,
            totalTokens: prompt.split(' ').length + 20
          }
        };
        
        // Simulate network delay
        await new Promise(resolve => setTimeout(resolve, 500));
        
        // Emit completion event
        this.events.emit('completion', {
          model,
          timestamp: new Date()
        });
        
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify(response)
            }
          ]
        };
      }
    );
  }