@vapi-ai/mcp-server 0.0.8 → 0.0.10

package/dist/schemas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,aAAa;;;;CAIhB,CAAC;AAEX,eAAO,MAAM,YAAY;;;CAGf,CAAC;AAEX,eAAO,MAAM,eAAe;;;CAGlB,CAAC;AAEX,eAAO,MAAM,YAAY;;;;;CAKf,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAC3B,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AACrD,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAC/E,MAAM,MAAM,kBAAkB,GAC5B,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC;AACzD,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAqC/E,eAAO,MAAM,WAAW;;;CAGvB,CAAC;AAEF,QAAA,MAAM,mBAAmB,wLAiBvB,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEpE,eAAO,MAAM,aAAa;cACF,iBAAiB;;CAExC,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;CAG/B,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;CAMrB,CAAC;AAIX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAI7B,CAAC;AAIH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDrC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBhC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;EAElC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDrC,CAAC;AAIH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgC1B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW3B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;EAE7B,CAAC;AAIH,eAAO,MAAM,yBAAyB;;;;;;EAEpC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUlC,CAAC;AAIH,eAAO,MAAM,kBAAkB;;;;;;EAE7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;EAM3B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"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"}

package/dist/schemas/index.js

@@ -285,10 +285,79 @@ export const PhoneNumberOutputSchema = BaseResponseSchema.extend({
 export const GetToolInputSchema = z.object({
     toolId: z.string().describe('ID of the tool to get'),
 });
+const TransferCallDestinationSchema = z.object({
+    type: z.literal('number'),
+    number: z.string().describe('Phone number to transfer to (e.g., "+16054440129"). It can be any phone number in E.164 format.'),
+    extension: z.string().optional().describe('Extension number if applicable'),
+    callerId: z.string().optional().describe('Caller ID to use for the transfer'),
+    description: z.string().optional().describe('Description of the transfer destination'),
+});
+// Generic custom tool schemas
+const JsonSchemaProperty = z.object({
+    type: z.string(),
+    description: z.string().optional(),
+    enum: z.array(z.string()).optional(),
+    items: z.any().optional(),
+    properties: z.record(z.any()).optional(),
+    required: z.array(z.string()).optional(),
+});
+const JsonSchema = z.object({
+    type: z.literal('object'),
+    properties: z.record(JsonSchemaProperty),
+    required: z.array(z.string()).optional(),
+});
+const ServerSchema = z.object({
+    url: z.string().url().describe('Server URL where the function will be called'),
+    headers: z.record(z.string()).optional().describe('Headers to send with the request'),
+});
+const BackoffPlanSchema = z.object({
+    type: z.enum(['fixed', 'exponential']).default('fixed'),
+    maxRetries: z.number().default(3).describe('Maximum number of retries'),
+    baseDelaySeconds: z.number().default(1).describe('Base delay between retries in seconds'),
+});
+// Base tool configuration schema (reusable for both create and update)
+const BaseToolConfigSchema = z.object({
+    // Common fields for all tools
+    name: z.string().optional().describe('Name of the function/tool'),
+    description: z.string().optional().describe('Description of what the function/tool does'),
+    // SMS tool configuration
+    sms: z.object({
+        metadata: z.object({
+            from: z.string().describe('Phone number to send SMS from (e.g., "+15551234567"). It must be a twilio number in E.164 format.'),
+        }).describe('SMS configuration metadata'),
+    }).optional().describe('SMS tool configuration - to send text messages'),
+    // Transfer call tool configuration
+    transferCall: z.object({
+        destinations: z.array(TransferCallDestinationSchema).describe('Array of possible transfer destinations'),
+    }).optional().describe('Transfer call tool configuration - to transfer calls to destinations'),
+    // Function tool configuration (custom functions with parameters)
+    function: z.object({
+        parameters: JsonSchema.describe('JSON schema for function parameters'),
+        server: ServerSchema.describe('Server configuration with URL where the function will be called'),
+    }).optional().describe('Custom function tool configuration - for custom server-side functions'),
+    // API Request tool configuration
+    apiRequest: z.object({
+        url: z.string().url().describe('URL to make the API request to'),
+        method: z.enum(['GET', 'POST']).default('POST').describe('HTTP method for the API request'),
+        headers: z.record(z.string()).optional().describe('Headers to send with the request (key-value pairs)'),
+        body: JsonSchema.optional().describe('Body schema for the API request in JSON Schema format'),
+        backoffPlan: BackoffPlanSchema.optional().describe('Retry configuration for failed API requests'),
+        timeoutSeconds: z.number().default(20).describe('Request timeout in seconds'),
+    }).optional().describe('API Request tool configuration - for HTTP API integration'),
+});
+export const CreateToolInputSchema = BaseToolConfigSchema.extend({
+    type: z.enum(['sms', 'transferCall', 'function', 'apiRequest'])
+        .describe('Type of the tool to create'),
+});
+export const UpdateToolInputSchema = BaseToolConfigSchema.extend({
+    toolId: z.string().describe('ID of the tool to update'),
+});
 export const ToolOutputSchema = BaseResponseSchema.extend({
     type: z
         .string()
         .describe('Type of the tool (dtmf, function, mcp, query, etc.)'),
     name: z.string().describe('Name of the tool'),
     description: z.string().describe('Description of the tool'),
+    parameters: z.record(z.any()).describe('Parameters of the tool'),
+    server: ServerSchema.describe('Server of the tool'),
 });

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,SAqBvB,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

@@ -1,8 +1,11 @@
-import { GetToolInputSchema } from '../schemas/index.js';
-import { transformToolOutput } from '../transformers/index.js';
+import { GetToolInputSchema, CreateToolInputSchema, UpdateToolInputSchema } from '../schemas/index.js';
+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);
     }));
@@ -10,4 +13,14 @@ export const registerToolTools = (server, vapiClient) => {
         const tool = await vapiClient.tools.get(data.toolId);
         return transformToolOutput(tool);
     }));
+    server.tool('create_tool', 'Creates a new Vapi tool', CreateToolInputSchema.shape, createToolHandler(async (data) => {
+        const createToolDto = transformToolInput(data);
+        const tool = await vapiClient.tools.create(createToolDto);
+        return transformToolOutput(tool);
+    }));
+    server.tool('update_tool', 'Updates an existing Vapi tool', UpdateToolInputSchema.shape, createToolHandler(async (data) => {
+        const updateToolDto = transformUpdateToolInput(data);
+        const tool = await vapiClient.tools.update(data.toolId, updateToolDto);
+        return transformToolOutput(tool);
+    }));
 };

package/dist/transformers/index.d.ts

@@ -1,11 +1,13 @@
 import { Vapi } from '@vapi-ai/server-sdk';
 import { z } from 'zod';
-import { CreateAssistantInputSchema, CallInputSchema, AssistantOutputSchema, CallOutputSchema, PhoneNumberOutputSchema, ToolOutputSchema, UpdateAssistantInputSchema } from '../schemas/index.js';
+import { CreateAssistantInputSchema, CallInputSchema, AssistantOutputSchema, CallOutputSchema, PhoneNumberOutputSchema, ToolOutputSchema, UpdateAssistantInputSchema, CreateToolInputSchema, UpdateToolInputSchema } from '../schemas/index.js';
 export declare function transformAssistantInput(input: z.infer<typeof CreateAssistantInputSchema>): Vapi.CreateAssistantDto;
 export declare function transformUpdateAssistantInput(input: z.infer<typeof UpdateAssistantInputSchema>): Vapi.UpdateAssistantDto;
 export declare function transformAssistantOutput(assistant: Vapi.Assistant): z.infer<typeof AssistantOutputSchema>;
 export declare function transformCallInput(input: z.infer<typeof CallInputSchema>): Vapi.CreateCallDto;
 export declare function transformCallOutput(call: Vapi.Call): z.infer<typeof CallOutputSchema>;
 export declare function transformPhoneNumberOutput(phoneNumber: any): z.infer<typeof PhoneNumberOutputSchema>;
-export declare function transformToolOutput(tool: any): z.infer<typeof ToolOutputSchema>;
+export declare function transformToolInput(input: z.infer<typeof CreateToolInputSchema>): any;
+export declare function transformUpdateToolInput(input: z.infer<typeof UpdateToolInputSchema>): any;
+export declare function transformToolOutput(tool: Vapi.ToolsGetResponse): z.infer<typeof ToolOutputSchema>;
 //# sourceMappingURL=index.d.ts.map

package/dist/transformers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transformers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAC3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,0BAA0B,EAC1B,eAAe,EACf,qBAAqB,EACrB,gBAAgB,EAChB,uBAAuB,EACvB,gBAAgB,EAChB,0BAA0B,EAC3B,MAAM,qBAAqB,CAAC;AAI7B,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,GAChD,IAAI,CAAC,kBAAkB,CA2CzB;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,GAChD,IAAI,CAAC,kBAAkB,CAiEzB;AAED,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,IAAI,CAAC,SAAS,GACxB,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAqBvC;AA2BD,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,GACrC,IAAI,CAAC,aAAa,CAwBpB;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,IAAI,CAAC,IAAI,GACd,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAgBlC;AAID,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,GAAG,GACf,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CASzC;AAID,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,GAAG,GACR,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CASlC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transformers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAC3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,0BAA0B,EAC1B,eAAe,EACf,qBAAqB,EACrB,gBAAgB,EAChB,uBAAuB,EACvB,gBAAgB,EAChB,0BAA0B,EAC1B,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,qBAAqB,CAAC;AAI7B,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,GAChD,IAAI,CAAC,kBAAkB,CA2CzB;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,GAChD,IAAI,CAAC,kBAAkB,CAiEzB;AAED,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,IAAI,CAAC,SAAS,GACxB,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAqBvC;AA2BD,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,GACrC,IAAI,CAAC,aAAa,CAwBpB;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,IAAI,CAAC,IAAI,GACd,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAgBlC;AAID,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,GAAG,GACf,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CASzC;AAID,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,GAC3C,GAAG,CA8DL;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,GAC3C,GAAG,CAiDL;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,IAAI,CAAC,gBAAgB,GAC1B,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAclC"}

package/dist/transformers/index.js

@@ -188,6 +188,115 @@ export function transformPhoneNumberOutput(phoneNumber) {
     };
 }
 // ===== Tool Transformers =====
+export function transformToolInput(input) {
+    let toolDto = {
+        type: input.type,
+    };
+    // Add function definition if name and description are provided
+    if (input.name || input.description) {
+        toolDto.function = {
+            ...(input.name && { name: input.name }),
+            ...(input.description && { description: input.description }),
+        };
+    }
+    // Handle different tool types using the new nested structure
+    switch (input.type) {
+        case 'sms':
+            if (input.sms?.metadata) {
+                toolDto.metadata = input.sms.metadata;
+            }
+            break;
+        case 'transferCall':
+            if (input.transferCall?.destinations) {
+                toolDto.destinations = input.transferCall.destinations;
+            }
+            break;
+        case 'function':
+            if (input.function?.parameters && input.function?.server) {
+                // For function tools, add parameters to the existing function object
+                if (toolDto.function) {
+                    toolDto.function.parameters = input.function.parameters;
+                }
+                else {
+                    toolDto.function = {
+                        parameters: input.function.parameters,
+                    };
+                }
+                toolDto.server = {
+                    url: input.function.server.url,
+                    ...(input.function.server.headers && { headers: input.function.server.headers }),
+                };
+            }
+            break;
+        case 'apiRequest':
+            if (input.apiRequest?.url) {
+                toolDto.url = input.apiRequest.url;
+                toolDto.method = input.apiRequest.method || 'POST';
+                if (input.apiRequest.headers)
+                    toolDto.headers = input.apiRequest.headers;
+                if (input.apiRequest.body)
+                    toolDto.body = input.apiRequest.body;
+                if (input.apiRequest.backoffPlan)
+                    toolDto.backoffPlan = input.apiRequest.backoffPlan;
+                if (input.apiRequest.timeoutSeconds)
+                    toolDto.timeoutSeconds = input.apiRequest.timeoutSeconds;
+            }
+            break;
+        default:
+            throw new Error(`Unsupported tool type: ${input.type}`);
+    }
+    return toolDto;
+}
+export function transformUpdateToolInput(input) {
+    let updateDto = {};
+    // Add function definition if name and description are provided
+    if (input.name || input.description) {
+        updateDto.function = {
+            ...(input.name && { name: input.name }),
+            ...(input.description && { description: input.description }),
+        };
+    }
+    // Handle SMS tool configuration
+    if (input.sms?.metadata) {
+        updateDto.metadata = input.sms.metadata;
+    }
+    // Handle Transfer call tool configuration
+    if (input.transferCall?.destinations) {
+        updateDto.destinations = input.transferCall.destinations;
+    }
+    // Handle Function tool configuration
+    if (input.function?.parameters && input.function?.server) {
+        // For function tools, add parameters to the existing function object
+        if (updateDto.function) {
+            updateDto.function.parameters = input.function.parameters;
+        }
+        else {
+            updateDto.function = {
+                parameters: input.function.parameters,
+            };
+        }
+        updateDto.server = {
+            url: input.function.server.url,
+            ...(input.function.server.headers && { headers: input.function.server.headers }),
+        };
+    }
+    // Handle API Request tool configuration
+    if (input.apiRequest) {
+        if (input.apiRequest.url)
+            updateDto.url = input.apiRequest.url;
+        if (input.apiRequest.method)
+            updateDto.method = input.apiRequest.method;
+        if (input.apiRequest.headers)
+            updateDto.headers = input.apiRequest.headers;
+        if (input.apiRequest.body)
+            updateDto.body = input.apiRequest.body;
+        if (input.apiRequest.backoffPlan)
+            updateDto.backoffPlan = input.apiRequest.backoffPlan;
+        if (input.apiRequest.timeoutSeconds)
+            updateDto.timeoutSeconds = input.apiRequest.timeoutSeconds;
+    }
+    return updateDto;
+}
 export function transformToolOutput(tool) {
     return {
         id: tool.id,
@@ -196,5 +305,10 @@ export function transformToolOutput(tool) {
         type: tool.type || '',
         name: tool.function?.name || '',
         description: tool.function?.description || '',
+        parameters: tool.function?.parameters || {},
+        server: {
+            url: tool.server?.url || '',
+            headers: tool.server?.headers || {},
+        }
     };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vapi-ai/mcp-server",
-  "description": "Vapi MCP Server",
-  "version": "0.0.8",
+  "description": "Build AI voice assistants and phone agents with Vapi through the Model Context Protocol",
+  "version": "0.0.10",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -24,8 +24,10 @@
     "vapi",
     "mcp",
     "model-context-protocol",
+    "mcp-server",
+    "mcp-client",
     "ai",
-    "claude",
+    "voice-agents",
     "voice-api",
     "tool-calling"
   ],
@@ -34,16 +36,25 @@
   },
   "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();
-            }
-        });
-    });
-});