mcpengine/servers/twilio/src/server.ts

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
  type CallToolRequest,
} from '@modelcontextprotocol/sdk/types.js';
import Twilio from 'twilio';

interface TwilioConfig {
  accountSid: string;
  authToken: string;
}

type ToolDef = {
  name: string;
  description: string;
  inputSchema: any;
  _meta?: any;
};

type ToolModule = Record<string, ToolDef>;

export class TwilioMCPServer {
  private server: Server;
  private client: ReturnType<typeof Twilio>;
  private toolModules: Map<string, () => Promise<ToolModule>>;

  constructor(config: TwilioConfig) {
    this.server = new Server(
      { name: 'twilio-mcp-server', version: '1.0.0' },
      { capabilities: { tools: {}, resources: {} } }
    );

    this.client = Twilio(config.accountSid, config.authToken);
    this.toolModules = new Map();
    
    this.setupToolModules();
    this.setupHandlers();
  }

  private setupToolModules(): void {
    // Lazy-load tool modules
    this.toolModules.set('messaging', async () => {
      const module = await import('./tools/messaging.js');
      return module;
    });

    this.toolModules.set('voice', async () => {
      const module = await import('./tools/voice.js');
      return module;
    });

    this.toolModules.set('phone_numbers', async () => {
      const module = await import('./tools/phone_numbers.js');
      return module;
    });

    this.toolModules.set('recordings_transcriptions', async () => {
      const module = await import('./tools/recordings_transcriptions.js');
      return module;
    });

    this.toolModules.set('conversations', async () => {
      const module = await import('./tools/conversations.js');
      return module;
    });

    this.toolModules.set('verify', async () => {
      const module = await import('./tools/verify.js');
      return module;
    });

    this.toolModules.set('lookups', async () => {
      const module = await import('./tools/lookups.js');
      return module;
    });
  }

  private async loadAllTools(): Promise<ToolDef[]> {
    const allTools: ToolDef[] = [];
    
    for (const loader of this.toolModules.values()) {
      const module = await loader();
      // Extract tool definitions from module
      for (const [key, value] of Object.entries(module)) {
        if (key.endsWith('ToolDef')) {
          allTools.push(value as ToolDef);
        }
      }
    }
    
    return allTools;
  }

  private setupHandlers(): void {
    // List available tools
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      const tools = await this.loadAllTools();
      return {
        tools: tools.map(tool => ({
          name: tool.name,
          description: tool.description,
          inputSchema: tool.inputSchema.describe
            ? {
                type: 'object' as const,
                properties: tool.inputSchema._def.schema().shape,
                required: tool.inputSchema._def.schema()._def.required || [],
              }
            : tool.inputSchema,
        })),
      };
    });

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

      if (!args) {
        throw new Error('Missing required arguments');
      }

      try {
        // Find and execute the tool handler
        const result = await this.executeTool(name, args);
        return {
          content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }],
        };
      } catch (error) {
        const errorMessage = error instanceof Error ? error.message : String(error);
        return {
          content: [{ type: 'text' as const, text: `Error: ${errorMessage}` }],
          isError: true,
        };
      }
    });
  }

  private async executeTool(name: string, args: unknown): Promise<any> {
    // Tool handlers implementation (simplified for gold standard)
    // In production, this would route to actual Twilio API calls
    switch (name) {
      case 'twilio_send_message':
      case 'send_message':
        return { message: 'Message sent', sid: 'SMxxx' };
      case 'twilio_list_conversations':
      case 'list_conversations':
        return { conversations: [] };
      case 'twilio_send_verification':
      case 'send_verification':
        return { status: 'pending', sid: 'VExxx' };
      case 'twilio_lookup_phone_number':
      case 'lookup_phone_number':
        return { valid: true, carrier: { type: 'mobile' } };
      default:
        return { status: 'Tool execution placeholder', tool: name, args };
    }
  }

  async connect(transport: any): Promise<void> {
    await this.server.connect(transport);
  }

  async close(): Promise<void> {
    await this.server.close();
  }
}