@vapi-ai/mcp-server 0.0.1

package/README.md

@@ -0,0 +1,87 @@
+# Vapi MCP Server
+
+The Vapi [Model Context Protocol](https://modelcontextprotocol.com/) server allows you to integrate with Vapi APIs through function calling.
+
+## Setup
+
+To run the Vapi MCP server using npx, use the following command:
+
+```bash
+# To set up all available tools
+export VAPI_TOKEN=your_vapi_token
+
+npx -y @vapi-ai/mcp-server
+```
+
+### Usage with Claude Desktop
+
+Add the following to your `claude_desktop_config.json`. See [here](https://modelcontextprotocol.io/quickstart/user) for more details.
+
+```
+
+{
+  "mcpServers": {
+    "vapi-mcp-server": {
+      "command": "npx",
+      "args": [
+          "-y",
+          "@vapi-ai/mcp-server"
+      ],
+      "env": {
+        "VAPI_TOKEN": "<your_vapi_token>"
+      }
+    }
+  }
+}
+
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build the server
+npm run build
+```
+
+```bash
+# Run the server in development mode with hot reloading
+npm run dev
+```
+
+## Testing
+
+The project has two types of tests:
+
+### Unit Tests
+
+Unit tests use mocks to test the MCP server without making actual API calls to Vapi.
+
+```bash
+# Run unit tests
+npm run test:unit
+```
+
+### End-to-End Tests
+
+E2E tests run the full MCP server with actual API calls to Vapi.
+
+```bash
+# Set your Vapi API token
+export VAPI_TOKEN=your_token_here
+
+# Run E2E tests
+npm run test:e2e
+```
+
+Note: E2E tests require a valid Vapi API token to be set in the environment.
+
+## Running All Tests
+
+To run all tests at once:
+
+```bash
+npm test
+```

package/dist/__tests__/mcp-server-e2e.test.js

@@ -0,0 +1,239 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { join } from 'path';
+import { jest } from '@jest/globals';
+import dotenv from 'dotenv';
+import { parseToolResponse } from '../utils/response.js';
+dotenv.config();
+jest.setTimeout(15000);
+describe('MCP Server E2E Test', () => {
+    let mcpClient;
+    let transport;
+    beforeAll(async () => {
+        const serverScriptPath = join(process.cwd(), 'src', 'index.ts');
+        console.log(`Using server source at: ${serverScriptPath}`);
+        mcpClient = new Client({ name: 'vapi-e2e-test-client', version: '1.0.0' });
+        transport = new StdioClientTransport({
+            command: 'npx',
+            args: ['tsx', serverScriptPath],
+            env: {
+                ...process.env,
+                VAPI_TOKEN: process.env.VAPI_TOKEN || 'test-token',
+            },
+        });
+        console.log('Connecting to MCP server...');
+        await mcpClient.connect(transport);
+        console.log('Connected to server successfully');
+    });
+    afterAll(async () => {
+        console.log('Disconnecting from server...');
+        await mcpClient.close();
+        console.log('Disconnected from server');
+    });
+    test('should list available tools', async () => {
+        console.log('Requesting available tools...');
+        const toolsResult = await mcpClient.listTools();
+        expect(toolsResult.tools).toBeDefined();
+        expect(Array.isArray(toolsResult.tools)).toBe(true);
+        const toolNames = toolsResult.tools.map((tool) => tool.name);
+        console.log('Available tools:', toolNames);
+        expect(toolNames).toContain('list_assistants');
+        expect(toolNames).toContain('create_assistant');
+        expect(toolNames).toContain('get_assistant');
+        expect(toolNames).toContain('list_phone_numbers');
+        expect(toolNames).toContain('get_phone_number');
+        expect(toolNames).toContain('list_calls');
+        expect(toolNames).toContain('create_call');
+        expect(toolNames).toContain('get_call');
+    });
+    describe('Assistant Tools', () => {
+        test('should list all assistants', async () => {
+            console.log('Calling list_assistants tool...');
+            const rawResult = await mcpClient.callTool({
+                name: 'list_assistants',
+                arguments: {},
+            });
+            const result = parseToolResponse(rawResult);
+            expect(result).toBeDefined();
+            if (Array.isArray(result)) {
+                console.log(`Received ${result.length} assistants in array form`);
+            }
+            else {
+                console.log(`Received assistants in non-array form:`, result);
+            }
+        });
+        test('should create a new assistant', async () => {
+            console.log('Calling create_assistant tool...');
+            const assistantData = {
+                name: `Test Assistant ${Date.now()}`,
+                instructions: 'You are a helpful test assistant',
+                llm: {
+                    provider: 'openai',
+                    model: 'gpt-4o',
+                },
+                transcriber: {
+                    provider: 'deepgram',
+                    model: 'nova-3',
+                },
+                voice: {
+                    provider: '11labs',
+                    model: 'eleven_turbo_v2_5',
+                    voiceId: 'sarah',
+                },
+                firstMessage: "Hello, I'm your vapi assistant.",
+            };
+            const rawResult = await mcpClient.callTool({
+                name: 'create_assistant',
+                arguments: assistantData,
+            });
+            const result = parseToolResponse(rawResult);
+            expect(result).toBeDefined();
+            expect(result.id).toBeDefined();
+            expect(result.name).toBe(assistantData.name);
+            expect(result.llm.provider).toBe(assistantData.llm.provider);
+            expect(result.llm.model).toBe(assistantData.llm.model);
+            console.log(`Successfully created assistant with ID: ${result.id}`);
+        });
+        test('should get an assistant by ID', async () => {
+            console.log('Listing assistants to get the first one...');
+            const rawListResult = await mcpClient.callTool({
+                name: 'list_assistants',
+                arguments: {},
+            });
+            const listResult = parseToolResponse(rawListResult);
+            expect(listResult).toBeDefined();
+            expect(Array.isArray(listResult)).toBe(true);
+            if (listResult.length === 0) {
+                console.log('No assistants found, skipping get_assistant test.');
+                // Optionally, you could fail the test here or create an assistant first
+                return;
+            }
+            const firstAssistant = listResult[0];
+            expect(firstAssistant.id).toBeDefined();
+            const assistantId = firstAssistant.id;
+            const assistantName = firstAssistant.name;
+            console.log(`Attempting to fetch assistant with ID: ${assistantId} (Name: ${assistantName})`);
+            const rawGetResult = await mcpClient.callTool({
+                name: 'get_assistant',
+                arguments: { assistantId: assistantId },
+            });
+            const getResult = parseToolResponse(rawGetResult);
+            expect(getResult).toBeDefined();
+            expect(getResult.id).toBe(assistantId);
+            expect(getResult.name).toBe(assistantName); // Verify name matches too
+            console.log(`Successfully fetched assistant with ID: ${getResult.id}`);
+        });
+        test('should handle invalid assistant ID', async () => {
+            const invalidId = 'non-existent-assistant-id-' + Date.now();
+            console.log(`Testing error handling with invalid assistant ID: ${invalidId}`);
+            try {
+                const rawResult = await mcpClient.callTool({
+                    name: 'get_assistant',
+                    arguments: { assistantId: invalidId },
+                });
+                const result = parseToolResponse(rawResult);
+                // Check for error in the result
+                if (result.error ||
+                    (typeof result === 'string' &&
+                        (result.includes('Error') || result.includes('error')))) {
+                    // Test passed - we got an error response
+                    expect(true).toBe(true);
+                }
+                else {
+                    // If we somehow got a successful result, fail the test
+                    expect(result).toContain('error');
+                }
+            }
+            catch (error) {
+                // This is also acceptable - the API might throw instead of returning error
+                expect(error).toBeDefined();
+            }
+        });
+    });
+    describe('Phone Number Tools', () => {
+        test('should list all phone numbers', async () => {
+            console.log('Calling list_phone_numbers tool...');
+            const rawResult = await mcpClient.callTool({
+                name: 'list_phone_numbers',
+                arguments: {},
+            });
+            const result = parseToolResponse(rawResult);
+            expect(result).toBeDefined();
+            if (Array.isArray(result)) {
+                console.log(`Received ${result.length} phone numbers in array form`);
+            }
+            else {
+                console.log(`Received phone numbers in non-array form:`, result);
+            }
+        });
+        test('should handle invalid phone number ID', async () => {
+            const invalidId = 'non-existent-phone-number-id-' + Date.now();
+            console.log(`Testing error handling with invalid phone number ID: ${invalidId}`);
+            try {
+                const rawResult = await mcpClient.callTool({
+                    name: 'get_phone_number',
+                    arguments: { phoneNumberId: invalidId },
+                });
+                const result = parseToolResponse(rawResult);
+                // Check for error in the result
+                if (result.error ||
+                    (typeof result === 'string' &&
+                        (result.includes('Error') || result.includes('error')))) {
+                    // Test passed - we got an error response
+                    expect(true).toBe(true);
+                }
+                else {
+                    // If we somehow got a successful result, fail the test
+                    expect(result).toContain('error');
+                }
+            }
+            catch (error) {
+                // This is also acceptable - the API might throw instead of returning error
+                expect(error).toBeDefined();
+            }
+        });
+    });
+    describe('Call Tools', () => {
+        test('should list all calls', async () => {
+            console.log('Calling list_calls tool...');
+            const rawResult = await mcpClient.callTool({
+                name: 'list_calls',
+                arguments: {},
+            });
+            const result = parseToolResponse(rawResult);
+            expect(result).toBeDefined();
+            if (Array.isArray(result)) {
+                console.log(`Received ${result.length} calls in array form`);
+            }
+            else {
+                console.log(`Received calls in non-array form:`, result);
+            }
+        });
+        test('should handle invalid call ID', async () => {
+            const invalidId = 'non-existent-call-id-' + Date.now();
+            console.log(`Testing error handling with invalid call ID: ${invalidId}`);
+            try {
+                const rawResult = await mcpClient.callTool({
+                    name: 'get_call',
+                    arguments: { callId: invalidId },
+                });
+                const result = parseToolResponse(rawResult);
+                // Check for error in the result
+                if (result.error ||
+                    (typeof result === 'string' &&
+                        (result.includes('Error') || result.includes('error')))) {
+                    // Test passed - we got an error response
+                    expect(true).toBe(true);
+                }
+                else {
+                    // If we somehow got a successful result, fail the test
+                    expect(result).toContain('error');
+                }
+            }
+            catch (error) {
+                // This is also acceptable - the API might throw instead of returning error
+                expect(error).toBeDefined();
+            }
+        });
+    });
+});

package/dist/__tests__/mcp-server-mock.test.js

@@ -0,0 +1,34 @@
+import { jest } from '@jest/globals';
+import { createMcpServer } from '../index.js';
+import { createMockVapiClient } from './mocks/vapi-client.mock.js';
+jest.mock('../client.js', () => ({
+    createVapiClient: jest.fn(() => createMockVapiClient()),
+}));
+process.env.VAPI_TOKEN = 'test-mock-token';
+describe('MCP Server Unit Test (with mocks)', () => {
+    let mcpServer;
+    beforeAll(() => {
+        console.log('Creating MCP server with mocked Vapi client...');
+        mcpServer = createMcpServer();
+        console.log('MCP server created successfully');
+    });
+    test('server should be initialized correctly', () => {
+        expect(mcpServer).toBeDefined();
+        expect(typeof mcpServer).toBe('object');
+        expect(mcpServer.constructor.name).toBe('McpServer');
+        expect(mcpServer.connect).toBeDefined();
+        expect(typeof mcpServer.connect).toBe('function');
+    });
+    test('server should have required internal structures', () => {
+        expect(mcpServer._registeredTools).toBeDefined();
+        expect(typeof mcpServer._registeredTools).toBe('object');
+    });
+    test('server should have registered Vapi tools', () => {
+        const registeredTools = Object.keys(mcpServer._registeredTools);
+        expect(registeredTools.length).toBeGreaterThan(0);
+        console.log('Found registered tools:', registeredTools);
+        expect(registeredTools).toContain('list_assistants');
+        expect(registeredTools).toContain('create_assistant');
+        expect(registeredTools).toContain('get_assistant');
+    });
+});

package/dist/__tests__/mocks/vapi-client.mock.js

@@ -0,0 +1,43 @@
+export class MockVapiClient {
+    assistants = {
+        list: jest.fn().mockResolvedValue([
+            {
+                id: 'mock-assistant-id-1',
+                name: 'Mock Assistant 1',
+                model: 'gpt-4',
+                instructions: 'Example instructions',
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+            },
+            {
+                id: 'mock-assistant-id-2',
+                name: 'Mock Assistant 2',
+                model: 'claude-3-opus',
+                instructions: 'Another example',
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+            },
+        ]),
+        get: jest.fn().mockImplementation((id) => {
+            return Promise.resolve({
+                id,
+                name: `Mock Assistant ${id}`,
+                model: 'gpt-4',
+                instructions: 'Example instructions',
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+            });
+        }),
+        create: jest.fn().mockImplementation((data) => {
+            return Promise.resolve({
+                id: 'new-mock-assistant-id',
+                ...data,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+            });
+        }),
+    };
+}
+export const createMockVapiClient = () => {
+    return new MockVapiClient();
+};

package/dist/client.js

@@ -0,0 +1,7 @@
+import { VapiClient } from '@vapi-ai/server-sdk';
+export const createVapiClient = (token) => {
+    if (!token) {
+        throw new Error('No Vapi token available');
+    }
+    return new VapiClient({ token });
+};

package/dist/index.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerAllTools } from './tools/index.js';
+import { createVapiClient } from './client.js';
+import dotenv from 'dotenv';
+dotenv.config();
+function createMcpServer() {
+    const vapiToken = process.env.VAPI_TOKEN;
+    if (!vapiToken) {
+        throw new Error('VAPI_TOKEN environment variable is required');
+    }
+    const vapiClient = createVapiClient(vapiToken);
+    const mcpServer = new McpServer({
+        name: 'Vapi MCP',
+        version: '0.1.0',
+        capabilities: [],
+    });
+    registerAllTools(mcpServer, vapiClient);
+    return mcpServer;
+}
+async function main() {
+    try {
+        const mcpServer = createMcpServer();
+        const transport = new StdioServerTransport();
+        await mcpServer.connect(transport);
+        setupShutdownHandler(mcpServer);
+    }
+    catch (err) {
+        process.exit(1);
+    }
+}
+function setupShutdownHandler(mcpServer) {
+    process.on('SIGINT', async () => {
+        try {
+            await mcpServer.close();
+            process.exit(0);
+        }
+        catch (err) {
+            process.exit(1);
+        }
+    });
+}
+main().catch((err) => {
+    process.exit(1);
+});
+export { createMcpServer };

package/dist/schemas/index.js

@@ -0,0 +1,213 @@
+import { z } from 'zod';
+// ===== Model Provider and Models =====
+export const ModelProvider = {
+    OpenAI: 'openai',
+    Anthropic: 'anthropic',
+    GoogleAI: 'google',
+};
+export const OpenAIModels = {
+    GPT4o: 'gpt-4o',
+    GPT4oMini: 'gpt-4o-mini',
+};
+export const AnthropicModels = {
+    Claude3Sonnet: 'claude-3-7-sonnet-20250219',
+    Claude3Haiku: 'claude-3-5-haiku-20241022',
+};
+export const GoogleModels = {
+    GeminiPro: 'gemini-1.5-pro',
+    GeminiFlash: 'gemini-1.5-flash',
+    Gemini2Flash: 'gemini-2.0-flash',
+    Gemini2Pro: 'gemini-2.0-pro',
+};
+const OpenAILLMSchema = z.object({
+    provider: z.literal(ModelProvider.OpenAI),
+    model: z.enum([OpenAIModels.GPT4o, OpenAIModels.GPT4oMini]),
+});
+const AnthropicLLMSchema = z.object({
+    provider: z.literal(ModelProvider.Anthropic),
+    model: z.enum([
+        AnthropicModels.Claude3Sonnet,
+        AnthropicModels.Claude3Haiku,
+    ]),
+});
+const GoogleLLMSchema = z.object({
+    provider: z.literal(ModelProvider.GoogleAI),
+    model: z.enum([
+        GoogleModels.GeminiPro,
+        GoogleModels.GeminiFlash,
+        GoogleModels.Gemini2Flash,
+        GoogleModels.Gemini2Pro,
+    ]),
+});
+const GenericLLMSchema = z.object({
+    provider: z.string(),
+    model: z.string(),
+});
+const LLMSchema = z.union([
+    OpenAILLMSchema,
+    AnthropicLLMSchema,
+    GoogleLLMSchema,
+    GenericLLMSchema,
+]);
+export const DEFAULT_LLM = {
+    provider: ModelProvider.OpenAI,
+    model: OpenAIModels.GPT4o,
+};
+const VoiceProviderSchema = z.enum([
+    'vapi',
+    '11labs',
+    'azure',
+    'cartesia',
+    'custom-voice',
+    'deepgram',
+    '11labs',
+    'hume',
+    'lmnt',
+    'neuphonic',
+    'openai',
+    'playht',
+    'rime-ai',
+    'smallest-ai',
+    'tavus',
+    'sesame',
+]);
+export const DEFAULT_VOICE = {
+    provider: '11labs',
+    voiceId: 'sarah',
+};
+export const DEFAULT_TRANSCRIBER = {
+    provider: 'deepgram',
+    model: 'nova-3',
+};
+export const ElevenLabsVoiceIds = {
+    Sarah: 'sarah',
+    Phillip: 'phillip',
+    Steve: 'steve',
+    Joseph: 'joseph',
+    Myra: 'myra',
+};
+// ===== Common Schemas =====
+export const BaseResponseSchema = z.object({
+    id: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+// ===== Assistant Schemas =====
+export const CreateAssistantInputSchema = z.object({
+    name: z.string().describe('Name of the assistant'),
+    instructions: z
+        .string()
+        .optional()
+        .default('You are a helpful assistant.')
+        .describe('Instructions for the assistant'),
+    llm: z
+        .union([
+        LLMSchema,
+        z.string().transform((str) => {
+            try {
+                return JSON.parse(str);
+            }
+            catch (e) {
+                throw new Error(`Invalid LLM JSON string: ${str}`);
+            }
+        }),
+    ])
+        .default(DEFAULT_LLM)
+        .describe('LLM configuration'),
+    transcriber: z
+        .object({
+        provider: z.string().describe('Provider to use for transcription'),
+        model: z.string().describe('Transcription model to use'),
+    })
+        .default(DEFAULT_TRANSCRIBER)
+        .describe('Transcription configuration'),
+    voice: z
+        .object({
+        provider: VoiceProviderSchema.describe('Provider to use for voice'),
+        voiceId: z.string().describe('Voice ID to use'),
+        model: z.string().optional().describe('Voice model to use'),
+    })
+        .default(DEFAULT_VOICE)
+        .describe('Voice configuration'),
+    firstMessage: z
+        .string()
+        .optional()
+        .default('Hello, how can I help you today?')
+        .describe('First message to send'),
+    firstMessageMode: z
+        .enum([
+        'assistant-speaks-first',
+        'assistant-waits-for-user',
+        'assistant-speaks-first-with-model-generated-message',
+    ])
+        .default('assistant-speaks-first')
+        .optional()
+        .describe('First message mode'),
+});
+export const AssistantOutputSchema = BaseResponseSchema.extend({
+    name: z.string(),
+    llm: z.object({
+        provider: z.string(),
+        model: z.string(),
+    }),
+    voice: z.object({
+        provider: z.string(),
+        voiceId: z.string(),
+        model: z.string().optional(),
+    }),
+    transcriber: z.object({
+        provider: z.string(),
+        model: z.string(),
+    }),
+});
+export const GetAssistantInputSchema = z.object({
+    assistantId: z.string().describe('ID of the assistant to get'),
+});
+// ===== Call Schemas =====
+export const CallInputSchema = z.object({
+    assistantId: z
+        .string()
+        .optional()
+        .describe('ID of the assistant to use for the call'),
+    phoneNumberId: z
+        .string()
+        .optional()
+        .describe('ID of the phone number to use for the call'),
+    customer: z
+        .object({
+        phoneNumber: z.string().describe('Customer phone number'),
+    })
+        .optional()
+        .describe('Customer information'),
+});
+export const CallOutputSchema = BaseResponseSchema.extend({
+    status: z.string(),
+    endedReason: z.string().optional(),
+    assistantId: z.string().optional(),
+    phoneNumberId: z.string().optional(),
+    customer: z
+        .object({
+        phoneNumber: z.string(),
+    })
+        .optional(),
+});
+export const GetCallInputSchema = z.object({
+    callId: z.string().describe('ID of the call to get'),
+});
+// ===== Phone Number Schemas =====
+export const PhoneNumberInputSchema = z.object({
+    areaCode: z.string().describe('Area code to search for'),
+});
+export const PhoneNumberOutputSchema = BaseResponseSchema.extend({
+    phoneNumber: z.string(),
+    status: z.string(),
+    capabilities: z
+        .object({
+        sms: z.boolean().optional(),
+        voice: z.boolean().optional(),
+    })
+        .optional(),
+});
+export const GetPhoneNumberInputSchema = z.object({
+    phoneNumberId: z.string().describe('ID of the phone number to get'),
+});

package/dist/tools/assistant.js

@@ -0,0 +1,32 @@
+import { CreateAssistantInputSchema, GetAssistantInputSchema, } from '../schemas/index.js';
+import { transformAssistantInput, transformAssistantOutput, } from '../transformers/index.js';
+import { createToolHandler } from './utils.js';
+export const registerAssistantTools = (server, vapiClient) => {
+    server.tool('list_assistants', 'Lists all Vapi assistants', {}, createToolHandler(async () => {
+        //   console.log('list_assistants');
+        const assistants = await vapiClient.assistants.list({ limit: 10 });
+        //   console.log('assistants', assistants);
+        return assistants.map(transformAssistantOutput);
+    }));
+    server.tool('create_assistant', 'Creates a new Vapi assistant', CreateAssistantInputSchema.shape, createToolHandler(async (data) => {
+        //   console.log('create_assistant', data);
+        const createAssistantDto = transformAssistantInput(data);
+        const assistant = await vapiClient.assistants.create(createAssistantDto);
+        return transformAssistantOutput(assistant);
+    }));
+    server.tool('get_assistant', 'Gets a Vapi assistant by ID', GetAssistantInputSchema.shape, createToolHandler(async (data) => {
+        //   console.log('get_assistant', data);
+        const assistantId = data.assistantId;
+        try {
+            const assistant = await vapiClient.assistants.get(assistantId);
+            if (!assistant) {
+                throw new Error(`Assistant with ID ${assistantId} not found`);
+            }
+            return transformAssistantOutput(assistant);
+        }
+        catch (error) {
+            console.error(`Error getting assistant: ${error.message}`);
+            throw error;
+        }
+    }));
+};

package/dist/tools/call.js

@@ -0,0 +1,18 @@
+import { CallInputSchema, GetCallInputSchema } from '../schemas/index.js';
+import { transformCallInput, transformCallOutput, } from '../transformers/index.js';
+import { createToolHandler } from './utils.js';
+export const registerCallTools = (server, vapiClient) => {
+    server.tool('list_calls', 'Lists all Vapi calls', {}, createToolHandler(async () => {
+        const calls = await vapiClient.calls.list({ limit: 10 });
+        return calls.map(transformCallOutput);
+    }));
+    server.tool('create_call', 'Creates a outbound call', CallInputSchema.shape, createToolHandler(async (data) => {
+        const createCallDto = transformCallInput(data);
+        const call = await vapiClient.calls.create(createCallDto);
+        return transformCallOutput(call);
+    }));
+    server.tool('get_call', 'Gets details of a specific call', GetCallInputSchema.shape, createToolHandler(async (data) => {
+        const call = await vapiClient.calls.get(data.callId);
+        return transformCallOutput(call);
+    }));
+};

package/dist/tools/index.js

@@ -0,0 +1,8 @@
+import { registerAssistantTools } from './assistant.js';
+import { registerCallTools } from './call.js';
+import { registerPhoneNumberTools } from './phone-number.js';
+export const registerAllTools = (server, vapiClient) => {
+    registerAssistantTools(server, vapiClient);
+    registerCallTools(server, vapiClient);
+    registerPhoneNumberTools(server, vapiClient);
+};

package/dist/tools/phone-number.js

@@ -0,0 +1,14 @@
+import { transformPhoneNumberOutput } from '../transformers/index.js';
+import { createToolHandler, } from './utils.js';
+import { GetPhoneNumberInputSchema } from '../schemas/index.js';
+export const registerPhoneNumberTools = (server, vapiClient) => {
+    server.tool('list_phone_numbers', 'Lists all Vapi phone numbers', {}, createToolHandler(async () => {
+        const phoneNumbers = await vapiClient.phoneNumbers.list({ limit: 10 });
+        return phoneNumbers.map(transformPhoneNumberOutput);
+    }));
+    server.tool('get_phone_number', 'Gets details of a specific phone number', GetPhoneNumberInputSchema.shape, createToolHandler(async (data) => {
+        const phoneNumberId = data.phoneNumberId;
+        const phoneNumber = await vapiClient.phoneNumbers.get(phoneNumberId);
+        return transformPhoneNumberOutput(phoneNumber);
+    }));
+};

package/dist/tools/utils.js

@@ -0,0 +1,67 @@
+export function createSuccessResponse(data) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: typeof data === 'string' ? data : JSON.stringify(data),
+            },
+        ],
+    };
+}
+export function createErrorResponse(error) {
+    const errorMessage = error?.message || String(error);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Error: ${errorMessage}`,
+            },
+        ],
+    };
+}
+export function createToolHandler(handler) {
+    return async (params) => {
+        try {
+            const result = await handler(params);
+            return createSuccessResponse(result);
+        }
+        catch (error) {
+            return createErrorResponse(error);
+        }
+    };
+}
+export function createParamsSchema(schema) {
+    return {
+        properties: {
+            params: schema.shape || {},
+        },
+        required: ['params'],
+    };
+}
+export function createIdParamSchema(paramName, description) {
+    return {
+        properties: {
+            [paramName]: { type: 'string', description },
+        },
+        required: [paramName],
+    };
+}
+export const withErrorHandling = (handler) => {
+    return handler()
+        .then((result) => createSuccessResponse(result))
+        .catch((error) => createErrorResponse(error));
+};
+export const filterResponseWithSchema = (data, schema) => {
+    if (Array.isArray(data)) {
+        return data.map((item) => schema.parse(item));
+    }
+    return schema.parse(data);
+};
+export const withSchemaFiltering = (handler, schema) => {
+    return handler()
+        .then((result) => {
+        const filtered = filterResponseWithSchema(result, schema);
+        return createSuccessResponse(filtered);
+    })
+        .catch((error) => createErrorResponse(error));
+};

package/dist/transformers/index.js

@@ -0,0 +1,113 @@
+// ===== Assistant Transformers =====
+export function transformAssistantInput(input) {
+    const assistantDto = {
+        name: input.name,
+    };
+    assistantDto.model = {
+        provider: input.llm.provider,
+        model: input.llm.model,
+    };
+    if (input.instructions) {
+        assistantDto.model.messages = [
+            {
+                role: 'system',
+                content: input.instructions,
+            },
+        ];
+    }
+    assistantDto.transcriber = {
+        provider: input.transcriber.provider,
+        ...(input.transcriber.model ? { model: input.transcriber.model } : {}),
+    };
+    assistantDto.voice = {
+        provider: input.voice.provider,
+        voiceId: input.voice.voiceId,
+        ...(input.voice.model ? { model: input.voice.model } : {}),
+    };
+    if (input.firstMessage) {
+        assistantDto.firstMessage = input.firstMessage;
+    }
+    if (input.firstMessageMode) {
+        assistantDto.firstMessageMode = input.firstMessageMode;
+    }
+    return assistantDto;
+}
+export function transformAssistantOutput(assistant) {
+    return {
+        id: assistant.id,
+        createdAt: assistant.createdAt,
+        updatedAt: assistant.updatedAt,
+        name: assistant.name || 'Vapi Assistant',
+        llm: {
+            provider: assistant.model?.provider || 'openai',
+            model: assistant.model?.model || 'gpt-4o-mini',
+        },
+        voice: {
+            provider: assistant.voice?.provider || '11labs',
+            voiceId: getAssistantVoiceId(assistant.voice),
+            model: getAssistantVoiceModel(assistant.voice) || 'eleven_turbo_v2_5',
+        },
+        transcriber: {
+            provider: assistant.transcriber?.provider || 'deepgram',
+            model: getAssistantTranscriberModel(assistant.transcriber) || 'nova-3',
+        },
+    };
+}
+function getAssistantVoiceId(voice) {
+    if (!voice)
+        return '';
+    const voiceAny = voice;
+    return voiceAny.voiceId || voiceAny.voice || '';
+}
+function getAssistantVoiceModel(voice) {
+    if (!voice)
+        return '';
+    const voiceAny = voice;
+    return voiceAny.model || '';
+}
+function getAssistantTranscriberModel(transcriber) {
+    if (!transcriber)
+        return '';
+    const transcriberAny = transcriber;
+    return transcriberAny.model || transcriberAny.transcriber || '';
+}
+// ===== Call Transformers =====
+export function transformCallInput(input) {
+    return {
+        ...(input.assistantId ? { assistantId: input.assistantId } : {}),
+        ...(input.phoneNumberId ? { phoneNumberId: input.phoneNumberId } : {}),
+        ...(input.customer
+            ? {
+                customer: {
+                    number: input.customer.phoneNumber,
+                },
+            }
+            : {}),
+    };
+}
+export function transformCallOutput(call) {
+    return {
+        id: call.id,
+        createdAt: call.createdAt,
+        updatedAt: call.updatedAt,
+        status: call.status || '',
+        endedReason: call.endedReason,
+        assistantId: call.assistantId,
+        phoneNumberId: call.phoneNumberId,
+        customer: call.customer
+            ? {
+                phoneNumber: call.customer.number || '',
+            }
+            : undefined,
+    };
+}
+// ===== Phone Number Transformers =====
+export function transformPhoneNumberOutput(phoneNumber) {
+    return {
+        id: phoneNumber.id,
+        createdAt: phoneNumber.createdAt,
+        updatedAt: phoneNumber.updatedAt,
+        phoneNumber: phoneNumber.phoneNumber,
+        status: phoneNumber.status,
+    };
+}

package/dist/utils/response.js

@@ -0,0 +1,26 @@
+export function parseToolResponse(response) {
+    // If no response or it's a primitive, return as is
+    if (!response || typeof response !== 'object')
+        return response;
+    // Check for content array with text items
+    if (response.content && Array.isArray(response.content)) {
+        const textContent = response.content.find((item) => item.type === 'text')?.text;
+        if (textContent) {
+            // Check if it's an error message first
+            if (textContent.startsWith('Error:') || textContent.includes('error')) {
+                return { error: textContent };
+            }
+            try {
+                return JSON.parse(textContent);
+            }
+            catch (e) {
+                // Don't warn on expected error messages
+                if (!textContent.startsWith('Error:')) {
+                    console.warn('Failed to parse text content as JSON:', e);
+                }
+                return textContent;
+            }
+        }
+    }
+    return response;
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@vapi-ai/mcp-server",
+  "description": "Vapi MCP Server",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "type": "module",
+  "author": "ramsrib",
+  "keywords": [],
+  "repository": "https://github.com/VapiAI/mcp-server",
+  "bin": {
+    "mcp-server": "dist/index.js"
+  },
+  "scripts": {
+    "prepare": "npm run build",
+    "build": "tsc && shx chmod +x dist/*.js",
+    "start": "node dist/index.js",
+    "dev": "tsx watch src/index.ts",
+    "dev:example": "tsx examples/client.ts",
+    "inspector": "mcp-inspector",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "test:unit": "NODE_OPTIONS=--experimental-vm-modules jest src/tests/mcp-server-mock.test.ts",
+    "test:e2e": "NODE_OPTIONS=--experimental-vm-modules jest src/tests/mcp-server-e2e.test.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.9.0",
+    "@vapi-ai/server-sdk": "^0.5.2",
+    "dotenv": "^16.4.7",
+    "zod": "^3.24.2",
+    "zod-to-json-schema": "^3.24.5"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/inspector": "^0.8.2",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.14.0",
+    "jest": "^29.7.0",
+    "shx": "^0.4.0",
+    "ts-jest": "^29.3.1",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3"
+  }
+}