@vapi-ai/mcp-server 0.0.9 → 0.0.11

package/README.md

@@ -2,33 +2,32 @@
 
 [![smithery badge](https://smithery.ai/badge/@VapiAI/vapi-mcp-server)](https://smithery.ai/server/@VapiAI/vapi-mcp-server)
 
-The Vapi [Model Context Protocol](https://modelcontextprotocol.com/) server allows you to integrate with Vapi APIs through function calling.
+Build AI voice assistants and phone agents with [Vapi](https://vapi.ai) using the [Model Context Protocol](https://modelcontextprotocol.com/).
 
 <a href="https://glama.ai/mcp/servers/@VapiAI/mcp-server">
   <img width="380" height="200" src="https://glama.ai/mcp/servers/@VapiAI/mcp-server/badge" alt="Vapi Server MCP server" />
 </a>
 
-## Claude Desktop Setup
+## Setup
 
-1. Open `Claude Desktop` and press `CMD + ,` to go to `Settings`.
-2. Click on the `Developer` tab.
-3. Click on the `Edit Config` button.
-4. This will open the `claude_desktop_config.json` file in your file explorer.
-5. Get your Vapi API key from the Vapi dashboard (<https://dashboard.vapi.ai/org/api-keys>).
-6. Add the following to your `claude_desktop_config.json` file. See [here](https://modelcontextprotocol.io/quickstart/user) for more details.
-7. Restart the Claude Desktop after editing the config file.
+The MCP server requires a Vapi API key. Get one from the [Vapi dashboard](https://dashboard.vapi.ai/org/api-keys).
 
-### Local Configuration
+### Local Server (stdio)
+
+Configure any MCP client that supports local stdio servers to run:
+
+```text
+npx -y @vapi-ai/mcp-server
+```
+
+Set `VAPI_TOKEN` in the server environment. MCP client configuration formats vary, but the server definition generally looks like this:
 
 ```json
 {
   "mcpServers": {
-    "vapi-mcp-server": {
+    "vapi": {
       "command": "npx",
-      "args": [
-          "-y",
-          "@vapi-ai/mcp-server"
-      ],
+      "args": ["-y", "@vapi-ai/mcp-server"],
       "env": {
         "VAPI_TOKEN": "<your_vapi_token>"
       }
@@ -37,12 +36,29 @@ The Vapi [Model Context Protocol](https://modelcontextprotocol.com/) server allo
 }
 ```
 
-### Remote Configuration
+### Remote Server (Streamable HTTP)
+
+Clients that support remote MCP servers can connect directly:
+
+- URL: `https://mcp.vapi.ai/mcp`
+- Header: `Authorization: Bearer your_vapi_api_key_here`
+
+### Client-Specific Examples
+
+#### Claude Code
+
+```bash
+claude mcp add -e VAPI_TOKEN=your_vapi_token vapi -- npx -y @vapi-ai/mcp-server
+```
+
+#### Claude Desktop
+
+Use the local server configuration above in the Claude Desktop configuration file. To connect to the hosted server through an stdio bridge instead:
 
 ```json
 {
   "mcpServers": {
-    "vapi-mcp": {
+    "vapi": {
       "command": "npx",
       "args": [
         "mcp-remote",
@@ -58,40 +74,50 @@ The Vapi [Model Context Protocol](https://modelcontextprotocol.com/) server allo
 }
 ```
 
-### Example Usage with Claude Desktop
+### Optional Agent Skill
 
-1. Create or import a phone number using the Vapi dashboard (<https://dashboard.vapi.ai/phone-numbers>).
-2. Create a new assistant using the existing 'Appointment Scheduler' template in the Vapi dashboard (<https://dashboard.vapi.ai/assistants>).
-3. Make sure to configure Claude Desktop to use the Vapi MCP server and restart the Claude Desktop app.
-4. Ask Claude to initiate or schedule a call. See examples below:
+The [`skill`](./skill) directory contains reusable instructions for AI coding agents that support Agent Skills. Install it using your host's skill installation process.
 
-**Example 1:** Request an immediate call
+For Claude Code:
 
-```md
-I'd like to speak with my ShopHelper assistant to talk about my recent order. Can you have it call me at +1234567890?
+```bash
+mkdir -p ~/.claude/skills/vapi
+curl -o ~/.claude/skills/vapi/SKILL.md https://raw.githubusercontent.com/VapiAI/mcp-server/main/skill/SKILL.md
 ```
 
-**Example 2:** Schedule a future call
+---
+
+## Example Usage
 
-```md
-I need to schedule a call with Mary assistant for next Tuesday at 3:00 PM. My phone number is +1555123456.
+### Create a Voice Assistant
+
+Ask your MCP-enabled agent:
+```
+I want to build a voice assistant that can schedule appointments
 ```
 
-**Example 3:** Make a call with dynamic variables
+### Make an Outbound Call
 
-```md
-I want to call +1234567890 with my appointment reminder assistant. Use these details:
+```
+Call +1234567890 using my appointment reminder assistant with these details:
 - Customer name: Sarah Johnson
 - Appointment date: March 25th
 - Appointment time: 2:30 PM
-- Doctor name: Dr. Smith
 ```
 
+### Schedule a Future Call
+
+```
+Schedule a call with my support assistant for next Tuesday at 3:00 PM to +1555123456
+```
+
+---
+
 ## Using Variable Values in Assistant Prompts
 
-The `create_call` action supports passing dynamic variables through `assistantOverrides.variableValues`. These variables can be used in your assistant's prompts using double curly braces: `{{variableName}}`.
+The `create_call` action supports passing dynamic variables through `assistantOverrides.variableValues`. Use double curly braces in your assistant's prompts: `{{variableName}}`.
 
-### Example Assistant Prompt with Variables
+### Example Prompt with Variables
 
 ```
 Hello {{customerName}}, this is a reminder about your appointment on {{appointmentDate}} at {{appointmentTime}} with {{doctorName}}.
@@ -99,7 +125,7 @@ Hello {{customerName}}, this is a reminder about your appointment on {{appointme
 
 ### Default Variables
 
-The following variables are automatically available (no need to pass in variableValues):
+These are automatically available (no need to pass):
 
 - `{{now}}` - Current date and time (UTC)
 - `{{date}}` - Current date (UTC)
@@ -109,29 +135,58 @@ The following variables are automatically available (no need to pass in variable
 - `{{year}}` - Current year (UTC)
 - `{{customer.number}}` - Customer's phone number
 
-For more details on default variables and advanced date/time formatting, see the [official Vapi documentation](https://docs.vapi.ai/assistants/dynamic-variables#default-variables).
+See [Vapi documentation](https://docs.vapi.ai/assistants/dynamic-variables#default-variables) for advanced date/time formatting.
 
-## Remote MCP
+---
 
-To connect to Vapi's MCP server remotely:
+## Remote MCP Server
 
-### Streamable HTTP (Recommended)
+Connect to Vapi's hosted MCP server from any MCP client:
 
-The default and recommended way to connect is via Streamable HTTP Transport:
+### Streamable HTTP (Recommended)
 
-- Connect to `https://mcp.vapi.ai/mcp` from any MCP client using Streamable HTTP Transport
-- Include your Vapi API key as a bearer token in the request headers
-- Example header: `Authorization: Bearer your_vapi_api_key_here`
+- URL: `https://mcp.vapi.ai/mcp`
+- Header: `Authorization: Bearer your_vapi_api_key_here`
 
 ### SSE (Deprecated)
 
-Server-Sent Events (SSE) Transport is still supported but deprecated:
+- URL: `https://mcp.vapi.ai/sse`
+- Header: `Authorization: Bearer your_vapi_api_key_here`
+
+---
+
+## Available Tools
+
+### Assistants
+| Tool | Description |
+|------|-------------|
+| `list_assistants` | List all assistants |
+| `get_assistant` | Get assistant by ID |
+| `create_assistant` | Create new assistant |
+| `update_assistant` | Update assistant |
 
-- Connect to `https://mcp.vapi.ai/sse` from any MCP client using SSE Transport
-- Include your Vapi API key as a bearer token in the request headers
-- Example header: `Authorization: Bearer your_vapi_api_key_here`
+### Calls
+| Tool | Description |
+|------|-------------|
+| `list_calls` | List call history |
+| `get_call` | Get call details |
+| `create_call` | Start outbound call (immediate or scheduled) |
 
-This connection allows you to access Vapi's functionality remotely without running a local server.
+### Phone Numbers
+| Tool | Description |
+|------|-------------|
+| `list_phone_numbers` | List phone numbers |
+| `get_phone_number` | Get phone number details |
+
+### Tools (Function Calling)
+| Tool | Description |
+|------|-------------|
+| `list_tools` | List custom tools |
+| `get_tool` | Get tool details |
+| `create_tool` | Create tool for API integration |
+| `update_tool` | Update tool |
+
+---
 
 ## Development
 
@@ -139,101 +194,64 @@ This connection allows you to access Vapi's functionality remotely without runni
 # Install dependencies
 npm install
 
-# Build the server
+# Build
 npm run build
 
-# Use inspector to test the server
+# Test with MCP inspector
 npm run inspector
 ```
 
-Update your `claude_desktop_config.json` to use the local server.
+### Local Development Config
 
 ```json
 {
   "mcpServers": {
     "vapi-local": {
       "command": "node",
-      "args": [
-        "<path_to_vapi_mcp_server>/dist/index.js"
-      ],
+      "args": ["<path>/dist/index.js"],
       "env": {
         "VAPI_TOKEN": "<your_vapi_token>"
       }
-    },
+    }
   }
 }
 ```
 
 ### Testing
 
-The project has two types of tests:
+```bash
+# Safe default suite (build, mocked execution, contract, and stdio compatibility)
+npm test
 
-#### Unit Tests
+# Unit tests (mocked public tool execution and catalog contract)
+npm run test:unit
 
-Unit tests use mocks to test the MCP server without making actual API calls to Vapi.
+# Documentation/tool-catalog consistency lint
+npm run test:docs
 
-```bash
-# Run unit tests
-npm run test:unit
-```
+# Full TypeScript check (production and test code)
+npm run typecheck
 
-#### End-to-End Tests
+# Build and run local stdio protocol compatibility tests (no Vapi API calls)
+npm run test:stdio
 
-E2E tests run the full MCP server with actual API calls to Vapi.
+# Pack, install, and launch the package from a clean temporary consumer
+npm run test:package
 
-```bash
-# Set your Vapi API token
+# Live read-only API tests
 export VAPI_TOKEN=your_token_here
+npm run test:live:readonly
 
-# Run E2E tests
-npm run test:e2e
+# Live mutating tests (creates and cleans up disposable assistants and tools)
+export VAPI_TOKEN=your_test_org_token_here
+npm run test:live:mutating
 ```
 
-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
-```
+---
 
 ## References
 
-- [VAPI Remote MCP Server](https://mcp.vapi.ai/)
-- [VAPI MCP Tool](https://docs.vapi.ai/tools/mcp)
-- [VAPI MCP Server SDK](https://docs.vapi.ai/sdk/mcp-server)
+- [Vapi Documentation](https://docs.vapi.ai)
+- [Vapi Dashboard](https://dashboard.vapi.ai)
+- [Vapi Remote MCP Server](https://mcp.vapi.ai/)
 - [Model Context Protocol](https://modelcontextprotocol.com/)
-- [Claude Desktop](https://modelcontextprotocol.io/quickstart/user)
-
-## Supported Actions
-
-The Vapi MCP Server provides the following tools for integration:
-
-### Assistant Tools
-
-- `list_assistants`: Lists all Vapi assistants
-- `create_assistant`: Creates a new Vapi assistant
-- `update_assistant`: Updates an existing Vapi assistant
-- `get_assistant`: Gets a Vapi assistant by ID
-
-### Call Tools
-
-- `list_calls`: Lists all Vapi calls
-- `create_call`: Creates an outbound call with support for:
-  - Immediate or scheduled calls
-  - Dynamic variable values through `assistantOverrides`
-- `get_call`: Gets details of a specific call
-
-> **Note:** The `create_call` action supports scheduling calls for immediate execution or for a future time. You can also pass dynamic variables using `assistantOverrides.variableValues` to personalize assistant messages.
-
-### Phone Number Tools
-
-- `list_phone_numbers`: Lists all Vapi phone numbers
-- `get_phone_number`: Gets details of a specific phone number
-
-### Vapi Tools
-
-- `list_tools`: Lists all Vapi tools
-- `get_tool`: Gets details of a specific tool

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAQpE,iBAAS,eAAe,cAiBvB;AA8BD,OAAO,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAYpE,iBAAS,eAAe,cAgBvB;AAgCD,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/index.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
+import { readFileSync } from 'node:fs';
 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();
+const packageMetadata = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 function createMcpServer() {
     const vapiToken = process.env.VAPI_TOKEN;
     if (!vapiToken) {
@@ -13,8 +15,7 @@ function createMcpServer() {
     const vapiClient = createVapiClient(vapiToken);
     const mcpServer = new McpServer({
         name: 'Vapi MCP',
-        version: '0.1.0',
-        capabilities: [],
+        version: packageMetadata.version,
     });
     registerAllTools(mcpServer, vapiClient);
     return mcpServer;
@@ -27,6 +28,7 @@ async function main() {
         setupShutdownHandler(mcpServer);
     }
     catch (err) {
+        console.error('Failed to start MCP server:', err);
         process.exit(1);
     }
 }
@@ -42,6 +44,7 @@ function setupShutdownHandler(mcpServer) {
     });
 }
 main().catch((err) => {
+    console.error('Fatal error:', err);
     process.exit(1);
 });
 export { createMcpServer };

package/dist/schemas/index.d.ts

@@ -167,11 +167,11 @@ export declare const CreateAssistantInputSchema: z.ZodObject<{
     firstMessage?: string | undefined;
     firstMessageMode?: "assistant-speaks-first" | "assistant-waits-for-user" | "assistant-speaks-first-with-model-generated-message" | undefined;
 }>;
-export declare const AssistantOutputSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const AssistantOutputSchema: z.ZodObject<{
     id: z.ZodString;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
-}, {
+} & {
     name: z.ZodString;
     llm: z.ZodObject<{
         provider: z.ZodString;
@@ -207,7 +207,7 @@ export declare const AssistantOutputSchema: z.ZodObject<z.objectUtil.extendShape
         model: string;
     }>;
     toolIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     id: string;
     createdAt: string;
     updatedAt: string;
@@ -406,11 +406,11 @@ export declare const CallInputSchema: z.ZodObject<{
         variableValues?: Record<string, any> | undefined;
     } | undefined;
 }>;
-export declare const CallOutputSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const CallOutputSchema: z.ZodObject<{
     id: z.ZodString;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
-}, {
+} & {
     status: z.ZodString;
     endedReason: z.ZodOptional<z.ZodString>;
     assistantId: z.ZodOptional<z.ZodString>;
@@ -423,7 +423,7 @@ export declare const CallOutputSchema: z.ZodObject<z.objectUtil.extendShape<{
         number: string;
     }>>;
     scheduledAt: z.ZodOptional<z.ZodString>;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     status: string;
     id: string;
     createdAt: string;
@@ -462,11 +462,11 @@ export declare const GetPhoneNumberInputSchema: z.ZodObject<{
 }, {
     phoneNumberId: string;
 }>;
-export declare const PhoneNumberOutputSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const PhoneNumberOutputSchema: z.ZodObject<{
     id: z.ZodString;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
-}, {
+} & {
     name: z.ZodOptional<z.ZodString>;
     phoneNumber: z.ZodString;
     status: z.ZodString;
@@ -480,7 +480,7 @@ export declare const PhoneNumberOutputSchema: z.ZodObject<z.objectUtil.extendSha
         voice?: boolean | undefined;
         sms?: boolean | undefined;
     }>>;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     status: string;
     id: string;
     createdAt: string;
@@ -510,7 +510,7 @@ export declare const GetToolInputSchema: z.ZodObject<{
 }, {
     toolId: string;
 }>;
-export declare const CreateToolInputSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const CreateToolInputSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     sms: z.ZodOptional<z.ZodObject<{
@@ -772,9 +772,9 @@ export declare const CreateToolInputSchema: z.ZodObject<z.objectUtil.extendShape
         } | undefined;
         timeoutSeconds?: number | undefined;
     }>>;
-}, {
+} & {
     type: z.ZodEnum<["sms", "transferCall", "function", "apiRequest"]>;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     type: "function" | "sms" | "transferCall" | "apiRequest";
     function?: {
         parameters: {
@@ -893,7 +893,7 @@ export declare const CreateToolInputSchema: z.ZodObject<z.objectUtil.extendShape
         timeoutSeconds?: number | undefined;
     } | undefined;
 }>;
-export declare const UpdateToolInputSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const UpdateToolInputSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     sms: z.ZodOptional<z.ZodObject<{
@@ -1155,9 +1155,9 @@ export declare const UpdateToolInputSchema: z.ZodObject<z.objectUtil.extendShape
         } | undefined;
         timeoutSeconds?: number | undefined;
     }>>;
-}, {
+} & {
     toolId: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     toolId: string;
     function?: {
         parameters: {
@@ -1276,11 +1276,11 @@ export declare const UpdateToolInputSchema: z.ZodObject<z.objectUtil.extendShape
         timeoutSeconds?: number | undefined;
     } | undefined;
 }>;
-export declare const ToolOutputSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const ToolOutputSchema: z.ZodObject<{
     id: z.ZodString;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
-}, {
+} & {
     type: z.ZodString;
     name: z.ZodString;
     description: z.ZodString;
@@ -1295,7 +1295,7 @@ export declare const ToolOutputSchema: z.ZodObject<z.objectUtil.extendShape<{
         url: string;
         headers?: Record<string, string> | undefined;
     }>;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     type: string;
     id: string;
     createdAt: string;

package/dist/tools/assistant.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assistant.d.ts","sourceRoot":"","sources":["../../src/tools/assistant.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAQ,MAAM,qBAAqB,CAAC;AAavD,eAAO,MAAM,sBAAsB,GACjC,QAAQ,SAAS,EACjB,YAAY,UAAU,SA2EvB,CAAC"}
+{"version":3,"file":"assistant.d.ts","sourceRoot":"","sources":["../../src/tools/assistant.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAQ,MAAM,qBAAqB,CAAC;AAavD,eAAO,MAAM,sBAAsB,GACjC,QAAQ,SAAS,EACjB,YAAY,UAAU,SA6EvB,CAAC"}

package/dist/tools/assistant.js

@@ -2,7 +2,10 @@ import { CreateAssistantInputSchema, GetAssistantInputSchema, UpdateAssistantInp
 import { transformAssistantInput, transformAssistantOutput, transformUpdateAssistantInput, } from '../transformers/index.js';
 import { createToolHandler } from './utils.js';
 export const registerAssistantTools = (server, vapiClient) => {
-    server.tool('list_assistants', 'Lists all Vapi assistants', {}, createToolHandler(async () => {
+    server.registerTool('list_assistants', {
+        description: 'Lists all Vapi assistants',
+        inputSchema: {},
+    }, createToolHandler(async () => {
         //   console.log('list_assistants');
         const assistants = await vapiClient.assistants.list({ limit: 10 });
         //   console.log('assistants', assistants);

package/dist/tools/call.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"call.d.ts","sourceRoot":"","sources":["../../src/tools/call.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAQ,MAAM,qBAAqB,CAAC;AASvD,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,SAAS,EACjB,YAAY,UAAU,SAgCvB,CAAC"}
+{"version":3,"file":"call.d.ts","sourceRoot":"","sources":["../../src/tools/call.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAQ,MAAM,qBAAqB,CAAC;AASvD,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,SAAS,EACjB,YAAY,UAAU,SAkCvB,CAAC"}

package/dist/tools/call.js

@@ -2,7 +2,10 @@ 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 () => {
+    server.registerTool('list_calls', {
+        description: 'Lists all Vapi calls',
+        inputSchema: {},
+    }, createToolHandler(async () => {
         const calls = await vapiClient.calls.list({ limit: 10 });
         return calls.map(transformCallOutput);
     }));

package/dist/tools/phone-number.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"phone-number.d.ts","sourceRoot":"","sources":["../../src/tools/phone-number.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAMjD,eAAO,MAAM,wBAAwB,GACnC,QAAQ,SAAS,EACjB,YAAY,UAAU,SAsBvB,CAAC"}
+{"version":3,"file":"phone-number.d.ts","sourceRoot":"","sources":["../../src/tools/phone-number.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAMjD,eAAO,MAAM,wBAAwB,GACnC,QAAQ,SAAS,EACjB,YAAY,UAAU,SAwBvB,CAAC"}

package/dist/tools/phone-number.js

@@ -2,7 +2,10 @@ 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 () => {
+    server.registerTool('list_phone_numbers', {
+        description: 'Lists all Vapi phone numbers',
+        inputSchema: {},
+    }, createToolHandler(async () => {
         const phoneNumbers = await vapiClient.phoneNumbers.list({ limit: 10 });
         return phoneNumbers.map(transformPhoneNumberOutput);
     }));

package/dist/tools/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/tools/tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAQ,MAAM,qBAAqB,CAAC;AAMvD,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,SAAS,EACjB,YAAY,UAAU,SA2CvB,CAAC"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/tools/tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAQ,MAAM,qBAAqB,CAAC;AAMvD,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,SAAS,EACjB,YAAY,UAAU,SA6CvB,CAAC"}

package/dist/tools/tool.js

@@ -2,7 +2,10 @@ import { GetToolInputSchema, CreateToolInputSchema, UpdateToolInputSchema } from
 import { transformToolInput, transformUpdateToolInput, transformToolOutput } from '../transformers/index.js';
 import { createToolHandler } from './utils.js';
 export const registerToolTools = (server, vapiClient) => {
-    server.tool('list_tools', 'Lists all Vapi tools', {}, createToolHandler(async () => {
+    server.registerTool('list_tools', {
+        description: 'Lists all Vapi tools',
+        inputSchema: {},
+    }, createToolHandler(async () => {
         const tools = await vapiClient.tools.list({ limit: 10 });
         return tools.map(transformToolOutput);
     }));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vapi-ai/mcp-server",
-  "description": "Vapi MCP Server",
-  "version": "0.0.9",
+  "description": "Build AI voice assistants and phone agents with Vapi through the Model Context Protocol",
+  "version": "0.0.11",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -24,26 +24,37 @@
     "vapi",
     "mcp",
     "model-context-protocol",
+    "mcp-server",
+    "mcp-client",
     "ai",
-    "claude",
+    "voice-agents",
     "voice-api",
     "tool-calling"
   ],
   "bin": {
-    "@vapi-ai/mcp-server": "dist/index.js"
+    "mcp-server": "dist/index.js"
   },
   "scripts": {
     "prepare": "npm run build",
-    "build": "tsc && shx chmod +x dist/*.js",
+    "clean": "shx rm -rf dist",
+    "build": "npm run clean && tsc -p tsconfig.build.json && shx chmod +x dist/*.js",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
     "start": "node dist/index.js",
     "dev": "tsx watch src/index.ts",
     "dev:stdio-example": "tsx examples/stdio-client.ts",
     "dev:sse-example": "tsx examples/sse-client.ts",
     "dev:shttp-example": "tsx examples/shttp-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"
+    "pretest": "npm run build",
+    "test": "VAPI_TOKEN=test-mock-token NODE_OPTIONS=--experimental-vm-modules jest --runInBand --testPathIgnorePatterns='.*-live\\.test\\.ts$'",
+    "test:unit": "VAPI_TOKEN=test-mock-token NODE_OPTIONS=--experimental-vm-modules jest --runInBand src/__tests__/mcp-tool-execution.test.ts src/__tests__/mcp-tools-list.test.ts",
+    "test:docs": "NODE_OPTIONS=--experimental-vm-modules jest --runInBand src/__tests__/documentation-tools.test.ts",
+    "pretest:stdio": "npm run build",
+    "test:stdio": "VAPI_TOKEN=test-mock-token NODE_OPTIONS=--experimental-vm-modules jest --runInBand src/__tests__/mcp-stdio-compat.test.ts",
+    "pretest:package": "npm run build",
+    "test:package": "node scripts/package-smoke.mjs",
+    "test:live:readonly": "npm run build && RUN_VAPI_READONLY_TESTS=1 NODE_OPTIONS=--experimental-vm-modules jest --runInBand src/__tests__/mcp-server-readonly-live.test.ts",
+    "test:live:mutating": "npm run build && RUN_VAPI_MUTATING_TESTS=1 NODE_OPTIONS=--experimental-vm-modules jest --runInBand src/__tests__/mcp-server-mutating-live.test.ts"
   },
   "files": [
     "dist",
@@ -51,14 +62,14 @@
     "dist/**/*.d.ts.map"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.3",
+    "@modelcontextprotocol/sdk": "1.26.0",
     "@vapi-ai/server-sdk": "^0.5.2",
     "dotenv": "^16.4.7",
-    "zod": "^3.24.2",
+    "zod": "^3.25.76",
     "zod-to-json-schema": "^3.24.5"
   },
   "devDependencies": {
-    "@modelcontextprotocol/inspector": "^0.14.2",
+    "@modelcontextprotocol/inspector": "1.0.1",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.14.0",
     "jest": "^29.7.0",

package/dist/__tests__/mcp-server-e2e.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=mcp-server-e2e.test.d.ts.map

package/dist/__tests__/mcp-server-e2e.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-server-e2e.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/mcp-server-e2e.test.ts"],"names":[],"mappings":""}

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

@@ -1,239 +0,0 @@
-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.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=mcp-server-mock.test.d.ts.map

package/dist/__tests__/mcp-server-mock.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-server-mock.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/mcp-server-mock.test.ts"],"names":[],"mappings":""}

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

@@ -1,34 +0,0 @@
-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.d.ts

@@ -1,9 +0,0 @@
-export declare class MockVapiClient {
-    assistants: {
-        list: jest.Mock<any, any, any>;
-        get: jest.Mock<any, any, any>;
-        create: jest.Mock<any, any, any>;
-    };
-}
-export declare const createMockVapiClient: () => MockVapiClient;
-//# sourceMappingURL=vapi-client.mock.d.ts.map

package/dist/__tests__/mocks/vapi-client.mock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vapi-client.mock.d.ts","sourceRoot":"","sources":["../../../src/__tests__/mocks/vapi-client.mock.ts"],"names":[],"mappings":"AAAA,qBAAa,cAAc;IACzB,UAAU;;;;MAuCR;CACH;AAED,eAAO,MAAM,oBAAoB,sBAEhC,CAAC"}

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

@@ -1,43 +0,0 @@
-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();
-};