@vapi-ai/mcp-server 0.0.10 → 0.1.0

package/dist/tools/simulation.js

@@ -0,0 +1,133 @@
+import { CreateSimulationInputSchema, CreateSimulationPersonalityInputSchema, CreateSimulationScenarioInputSchema, CreateSimulationSuiteInputSchema, GetSimulationRunInputSchema, GetSimulationRunItemInputSchema, ListSimulationResourcesInputSchema, ListSimulationRunsInputSchema, ListSimulationScenariosInputSchema, RunSimulationsInputSchema, } from '../schemas/index.js';
+import { registerValidatedTool } from './validation.js';
+import { createToolHandler } from './utils.js';
+const DEFAULT_LIMIT = 50;
+// Run items carry call snapshots and transcripts in these fields, which can
+// be large. get_simulation_run leaves them out; get_simulation_run_item
+// returns them.
+const LARGE_RUN_ITEM_FIELDS = [
+    'metadata',
+    'configurations',
+    'improvementSuggestions',
+];
+function summarizeRunItem(item) {
+    const summary = { ...item };
+    for (const field of LARGE_RUN_ITEM_FIELDS) {
+        delete summary[field];
+    }
+    return summary;
+}
+export const registerSimulationTools = (server, vapiClient) => {
+    registerValidatedTool(server, 'list_simulation_personalities', {
+        description: 'Lists simulation personalities: the simulated callers (testers) used in Vapi simulations',
+        inputSchema: ListSimulationResourcesInputSchema,
+    }, createToolHandler(async (data) => vapiClient.simulationPersonalities.personalityControllerFindAll({
+        limit: data.limit ?? DEFAULT_LIMIT,
+    })));
+    registerValidatedTool(server, 'create_simulation_personality', {
+        description: 'Creates a simulation personality: the simulated caller that talks to the assistant under test',
+        inputSchema: CreateSimulationPersonalityInputSchema,
+    }, createToolHandler(async (data) => vapiClient.simulationPersonalities.personalityControllerCreate(data)));
+    registerValidatedTool(server, 'list_simulation_scenarios', {
+        description: 'Lists simulation scenarios: the scripts testers follow and the checks that decide pass or fail',
+        inputSchema: ListSimulationScenariosInputSchema,
+    }, createToolHandler(async (data) => vapiClient.simulationScenarios.scenarioControllerFindAll({
+        limit: data.limit ?? DEFAULT_LIMIT,
+        ...(data.name && { name: data.name }),
+    })));
+    registerValidatedTool(server, 'create_simulation_scenario', {
+        description: 'Creates a simulation scenario: instructions for the tester plus evaluations that decide whether the assistant passed',
+        inputSchema: CreateSimulationScenarioInputSchema,
+    }, createToolHandler(async ({ additionalFields, ...data }) => vapiClient.simulationScenarios.scenarioControllerCreate({
+        ...data,
+        ...additionalFields,
+    })));
+    registerValidatedTool(server, 'list_simulations', {
+        description: 'Lists simulations. Each simulation pairs one scenario with one personality.',
+        inputSchema: ListSimulationResourcesInputSchema,
+    }, createToolHandler(async (data) => vapiClient.simulations.simulationControllerFindAll({
+        limit: data.limit ?? DEFAULT_LIMIT,
+    })));
+    registerValidatedTool(server, 'create_simulation', {
+        description: 'Creates a simulation that pairs a scenario with a personality. Run it with run_simulations.',
+        inputSchema: CreateSimulationInputSchema,
+    }, createToolHandler(async (data) => vapiClient.simulations.simulationControllerCreate(data)));
+    registerValidatedTool(server, 'list_simulation_suites', {
+        description: 'Lists simulation suites: named groups of simulations',
+        inputSchema: ListSimulationResourcesInputSchema,
+    }, createToolHandler(async (data) => vapiClient.simulationSuites.simulationSuiteControllerFindAll({
+        limit: data.limit ?? DEFAULT_LIMIT,
+    })));
+    registerValidatedTool(server, 'create_simulation_suite', {
+        description: 'Creates a simulation suite that groups simulations so they can be run together',
+        inputSchema: CreateSimulationSuiteInputSchema,
+    }, createToolHandler(async ({ additionalFields, ...data }) => vapiClient.simulationSuites.simulationSuiteControllerCreate({
+        ...data,
+        ...additionalFields,
+    })));
+    registerValidatedTool(server, 'run_simulations', {
+        description: 'Starts a simulation run of simulations and/or suites against an assistant or squad. ' +
+            'Returns the run with its ID and a dashboard URL to share with the user. Check progress with get_simulation_run.',
+        inputSchema: RunSimulationsInputSchema,
+    }, createToolHandler(async (data) => {
+        const simulations = [
+            ...(data.simulationIds ?? []).map((simulationId) => ({
+                type: 'simulation',
+                simulationId,
+            })),
+            ...(data.suiteIds ?? []).map((simulationSuiteId) => ({
+                type: 'simulationSuite',
+                simulationSuiteId,
+            })),
+        ];
+        return vapiClient.simulationRuns.simulationRunControllerCreate({
+            simulations,
+            target: data.assistantId
+                ? { type: 'assistant', assistantId: data.assistantId }
+                : { type: 'squad', squadId: data.squadId },
+            ...(data.iterations && { iterations: data.iterations }),
+            ...(data.transport && { transport: { provider: data.transport } }),
+        }, data.idempotencyKey
+            ? { headers: { 'Idempotency-Key': data.idempotencyKey } }
+            : undefined);
+    }));
+    registerValidatedTool(server, 'list_simulation_runs', {
+        description: 'Lists simulation runs, newest first',
+        inputSchema: ListSimulationRunsInputSchema,
+    }, createToolHandler(async (data) => vapiClient.simulationRuns.simulationRunControllerFindAll({
+        limit: data.limit ?? DEFAULT_LIMIT,
+        ...(data.status && { status: data.status }),
+        ...(data.targetId && { targetId: data.targetId }),
+    })));
+    registerValidatedTool(server, 'get_simulation_run', {
+        description: 'Gets a simulation run with its status, item counts, and the first 100 item summaries. ' +
+            'itemsTruncated indicates omitted items; itemsMetadata preserves API pagination metadata. ' +
+            'Use get_simulation_run_item for an item’s transcript and call details.',
+        inputSchema: GetSimulationRunInputSchema,
+    }, createToolHandler(async (data) => {
+        const [run, response] = await Promise.all([
+            vapiClient.simulationRuns.simulationRunControllerFindOne({
+                id: data.runId,
+            }),
+            vapiClient.simulationRuns.simulationRunControllerFindItems({
+                id: data.runId,
+                limit: 100,
+            }),
+        ]);
+        const page = response;
+        const items = Array.isArray(page) ? page : page.results;
+        return {
+            ...run,
+            items: items.map(summarizeRunItem),
+            itemsTruncated: !Array.isArray(page) && page.metadata.totalItems > items.length,
+            ...(!Array.isArray(page) && { itemsMetadata: page.metadata }),
+        };
+    }));
+    registerValidatedTool(server, 'get_simulation_run_item', {
+        description: 'Gets one simulation run item in full, including results, call snapshots, transcript, and improvement suggestions',
+        inputSchema: GetSimulationRunItemInputSchema,
+    }, createToolHandler(async (data) => vapiClient.simulationRuns.simulationRunControllerFindItem({
+        id: data.runId,
+        itemId: data.itemId,
+    })));
+};

package/dist/tools/skills.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerSkillTools(server: McpServer): void;
+//# sourceMappingURL=skills.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../src/tools/skills.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAiBzE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,QAkBnD"}

package/dist/tools/skills.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { PublicSkills } from '../knowledge/skills.js';
+async function knowledgeResult(action) {
+    try {
+        return await action();
+    }
+    catch (error) {
+        return { isError: true, content: [{ type: 'text', text: `Knowledge request failed: ${error instanceof Error ? error.message : 'Unknown upstream error'}` }] };
+    }
+}
+function jsonResult(data) {
+    return { content: [{ type: 'text', text: JSON.stringify(data) }], structuredContent: data };
+}
+export function registerSkillTools(server) {
+    const skills = new PublicSkills();
+    const annotations = { readOnlyHint: true, destructiveHint: false, openWorldHint: true };
+    server.registerTool('search_skills', {
+        description: 'Find Vapi agent skills in the public VapiAI/skills repository by name, description or content. Omit query to browse. Use load_skill to read a result.',
+        inputSchema: {
+            query: z.string().trim().max(500).default('').describe('Keywords describing the Vapi task, or empty to browse all skills.'),
+            limit: z.number().int().min(1).max(30).default(10),
+        }, annotations,
+    }, ({ query, limit }) => knowledgeResult(async () => jsonResult(await skills.search(query, limit))));
+    server.registerTool('load_skill', {
+        description: 'Read a public Vapi skill or one of its supporting files. Start with SKILL.md, then load relevant files from the returned file list as needed. Returns instructions for this task; does not install skills or execute scripts.',
+        inputSchema: {
+            name: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).max(100).describe('Exact skill name from search_skills.'),
+            path: z.string().min(1).max(300).default('SKILL.md').describe('File path relative to the skill directory, such as SKILL.md or references/hooks.md.'),
+        }, annotations,
+    }, ({ name, path }) => knowledgeResult(async () => jsonResult(await skills.load(name, path))));
+}

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,SA6CvB,CAAC"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/tools/tool.ts"],"names":[],"mappings":"AACA,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,SA2DvB,CAAC"}

package/dist/tools/tool.js

@@ -1,26 +1,40 @@
-import { GetToolInputSchema, CreateToolInputSchema, UpdateToolInputSchema } from '../schemas/index.js';
+import { registerValidatedTool } from './validation.js';
+import { EmptyInputSchema, 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.registerTool('list_tools', {
+    registerValidatedTool(server, 'list_tools', {
         description: 'Lists all Vapi tools',
-        inputSchema: {},
+        inputSchema: EmptyInputSchema,
     }, createToolHandler(async () => {
         const tools = await vapiClient.tools.list({ limit: 10 });
         return tools.map(transformToolOutput);
     }));
-    server.tool('get_tool', 'Gets details of a specific tool', GetToolInputSchema.shape, createToolHandler(async (data) => {
-        const tool = await vapiClient.tools.get(data.toolId);
+    registerValidatedTool(server, 'get_tool', {
+        description: 'Gets details of a specific tool',
+        inputSchema: GetToolInputSchema,
+    }, createToolHandler(async (data) => {
+        const tool = await vapiClient.tools.get({ id: data.toolId });
         return transformToolOutput(tool);
     }));
-    server.tool('create_tool', 'Creates a new Vapi tool', CreateToolInputSchema.shape, createToolHandler(async (data) => {
+    registerValidatedTool(server, 'create_tool', {
+        description: 'Creates a new Vapi tool',
+        inputSchema: CreateToolInputSchema,
+    }, 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);
+    registerValidatedTool(server, 'update_tool', {
+        description: 'Updates an existing Vapi tool',
+        inputSchema: UpdateToolInputSchema,
+    }, createToolHandler(async (data) => {
+        const existingTool = await vapiClient.tools.get({ id: data.toolId });
+        const updateToolDto = transformUpdateToolInput(data, existingTool);
+        const tool = await vapiClient.tools.update({
+            id: data.toolId,
+            body: updateToolDto,
+        });
         return transformToolOutput(tool);
     }));
 };

package/dist/tools/validation.d.ts

@@ -0,0 +1,22 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { ToolResponse } from './utils.js';
+type Issue = z.core.$ZodIssue;
+type FieldIssue = {
+    path: string;
+    code: string;
+    message: string;
+    allowedValues?: unknown[];
+    allowedValuesTruncated?: boolean;
+    expected?: string;
+    minimum?: number;
+    maximum?: number;
+    format?: string;
+};
+export declare function validationIssues(issues: Issue[], input: unknown, prefix?: PropertyKey[]): FieldIssue[];
+export declare function registerValidatedTool<Schema extends z.ZodType>(server: McpServer, name: string, config: {
+    description: string;
+    inputSchema: Schema;
+}, handler: (params: z.output<Schema>) => Promise<ToolResponse>): import("@modelcontextprotocol/sdk/server/mcp.js").RegisteredTool;
+export {};
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/tools/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,KAAK,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;AAC9B,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,EAAE,CAAC;IACvE,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CACxE,CAAC;AAcF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,GAAE,WAAW,EAAO,GAAG,UAAU,EAAE,CA8C1G;AAWD,wBAAgB,qBAAqB,CAAC,MAAM,SAAS,CAAC,CAAC,OAAO,EAC5D,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,EACpD,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,OAAO,CAAC,YAAY,CAAC,oEAsB7D"}

package/dist/tools/validation.js

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import { summarizeInputSchema } from './input-schema.js';
+const MAX_ISSUES = 12;
+const MAX_OPTIONS = 8;
+const at = (input, path) => path.reduce((value, key) => value !== null && typeof value === 'object' ? value[key] : undefined, input);
+const fieldPath = (path) => path.map((key, index) => typeof key === 'number' ? `[${key}]` : `${index ? '.' : ''}${String(key)}`).join('') || '$';
+const matchesShape = (issues, kind) => !issues.some(issue => issue.path.length === 0 && (issue.code === 'invalid_type' && issue.expected !== kind ||
+    issue.code === 'invalid_union' && issue.errors.every(branch => !matchesShape(branch, kind))));
+// Select the supplied provider's branch before formatting a union failure.
+// Otherwise a single forbidden field can emit dozens of unrelated providers.
+export function validationIssues(issues, input, prefix = []) {
+    return issues.flatMap((issue) => {
+        const path = [...prefix, ...issue.path];
+        if (issue.code === 'invalid_union') {
+            const value = at(input, path);
+            const kind = Array.isArray(value) ? 'array' : value === null ? 'null' : typeof value;
+            const compatible = issue.errors.filter(branch => matchesShape(branch, kind));
+            if (compatible.length === 1)
+                return validationIssues(compatible[0], input, path);
+            let record = value && typeof value === 'object' ? value : {};
+            // LLM configuration also accepts a JSON string. Decode only to select
+            // the correct branch; submitted values never enter the error response.
+            if (typeof value === 'string') {
+                try {
+                    const decoded = JSON.parse(value);
+                    if (decoded && typeof decoded === 'object')
+                        record = decoded;
+                }
+                catch { /* The JSON parser's existing issue supplies the correction. */ }
+            }
+            const missingDiscriminator = compatible.length ? ['provider', 'type'].find(key => compatible.every(branch => branch.some(child => child.path.length === 1 && child.path[0] === key && child.code === 'invalid_value'))) : undefined;
+            const discriminator = missingDiscriminator ?? (typeof record.provider === 'string' ? 'provider' : typeof record.type === 'string' ? 'type' : undefined);
+            if (discriminator) {
+                const matches = compatible.filter(branch => !branch.some(child => child.path.length === 1 && child.path[0] === discriminator && child.code === 'invalid_value'));
+                if (matches.length === 1)
+                    return validationIssues(matches[0], input, path);
+                if (matches.length === 0) {
+                    const options = compatible.flatMap(branch => branch.flatMap(child => child.code === 'invalid_value' && child.path[0] === discriminator ? child.values : []));
+                    return [optionIssue([...path, discriminator], options)];
+                }
+            }
+            if (compatible.length && compatible.every(branch => branch.every(child => child.path.length === 0 && child.code === 'invalid_value'))) {
+                return [optionIssue(path, compatible.flatMap(branch => branch.flatMap(child => child.code === 'invalid_value' ? child.values : [])))];
+            }
+            const expected = [...new Set(issue.errors.flatMap(branch => branch.flatMap(child => child.code === 'invalid_type' && child.path.length === 0 ? [child.expected] : [])))];
+            return [{ path: fieldPath(path), code: 'invalid_union', message: expected.length ? `Expected ${expected.join(' or ')}.` : 'Does not match the supported configuration; check the API schema for this field.' }];
+        }
+        if (issue.code === 'unrecognized_keys')
+            return issue.keys.map(key => ({
+                path: fieldPath([...path, key]), code: 'unrecognized_key',
+                message: 'This field is not supported for the selected provider or configuration; remove it.',
+            }));
+        if (issue.code === 'invalid_value')
+            return [optionIssue(path, issue.values)];
+        const detail = { path: fieldPath(path), code: issue.code, message: issue.message.slice(0, 300) };
+        if (issue.code === 'invalid_type')
+            detail.expected = issue.expected;
+        if (issue.code === 'too_big' && typeof issue.maximum === 'number')
+            detail.maximum = issue.maximum;
+        if (issue.code === 'too_small' && typeof issue.minimum === 'number')
+            detail.minimum = issue.minimum;
+        if (issue.code === 'invalid_format')
+            detail.format = issue.format;
+        return [detail];
+    });
+}
+function optionIssue(path, values) {
+    const unique = [...new Set(values)];
+    const allowedValues = unique.slice(0, MAX_OPTIONS);
+    return {
+        path: fieldPath(path), code: 'invalid_value', allowedValues, allowedValuesTruncated: unique.length > MAX_OPTIONS,
+        message: `Expected one of: ${allowedValues.map(value => JSON.stringify(value)).join(', ')}${unique.length > MAX_OPTIONS ? ` (and ${unique.length - MAX_OPTIONS} more; see the API schema for this field)` : ''}.`,
+    };
+}
+export function registerValidatedTool(server, name, config, handler) {
+    const schema = config.inputSchema;
+    // Advertise a compact input summary, but run the full parser exactly once. This
+    // boundary lets us format validation failures before the SDK stringifies a
+    // raw ZodError. No request reaches the API handler before parsing succeeds.
+    const transportSchema = z.object({}).passthrough().meta(summarizeInputSchema(z.toJSONSchema(schema, { io: 'input', target: 'draft-07' })));
+    return server.registerTool(name, { description: config.description, inputSchema: transportSchema }, async (raw) => {
+        const parsed = await schema.safeParseAsync(raw);
+        if (!parsed.success) {
+            const all = validationIssues(parsed.error.issues, raw);
+            const issues = all.slice(0, MAX_ISSUES);
+            return {
+                isError: true,
+                content: [{ type: 'text', text: `Input validation error for ${name}:\n${issues.map(issue => `- ${issue.path}: ${issue.message}`).join('\n')}${all.length > MAX_ISSUES ? `\n${all.length - MAX_ISSUES} additional issues omitted.` : ''}\nCorrect the listed fields and retry.` }],
+                structuredContent: { validationError: { code: 'INVALID_ARGUMENTS', tool: name, issues, truncated: all.length > MAX_ISSUES } },
+            };
+        }
+        return handler(parsed.data);
+    });
+}

package/dist/transformers/index.d.ts

@@ -2,12 +2,12 @@ import { Vapi } from '@vapi-ai/server-sdk';
 import { z } from 'zod';
 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 transformUpdateAssistantInput(input: z.infer<typeof UpdateAssistantInputSchema>, existing?: Vapi.Assistant): 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 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>;
+export declare function transformUpdateToolInput(input: z.infer<typeof UpdateToolInputSchema>, existing?: Vapi.GetToolsResponse): any;
+export declare function transformToolOutput(tool: Vapi.GetToolsResponse): 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,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"}
+{"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,EACjD,QAAQ,CAAC,EAAE,IAAI,CAAC,SAAS,GACxB,IAAI,CAAC,kBAAkB,CAyEzB;AAED,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,IAAI,CAAC,SAAS,GACxB,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAuBvC;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,CAkEL;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,EAC5C,QAAQ,CAAC,EAAE,IAAI,CAAC,gBAAgB,GAC/B,GAAG,CA+DL;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,IAAI,CAAC,gBAAgB,GAC1B,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAiBlC"}

package/dist/transformers/index.js

@@ -35,42 +35,44 @@ export function transformAssistantInput(input) {
     }
     return assistantDto;
 }
-export function transformUpdateAssistantInput(input) {
+export function transformUpdateAssistantInput(input, existing) {
     const updateDto = {};
     if (input.name) {
         updateDto.name = input.name;
     }
-    if (input.llm) {
-        updateDto.model = {
-            provider: input.llm.provider,
-            model: input.llm.model,
-        };
-        if (input.toolIds && input.toolIds.length > 0) {
-            updateDto.model.toolIds = input.toolIds;
-        }
-        if (input.instructions) {
-            updateDto.model.messages = [
-                {
-                    role: 'system',
-                    content: input.instructions,
-                },
-            ];
+    const hasToolIds = !!input.toolIds && input.toolIds.length > 0;
+    if (input.llm || hasToolIds || input.instructions) {
+        // PATCH replaces `model` as a whole, so start from the assistant's current
+        // model. Sending only the changed fields drops `provider`/`model` and the
+        // API rejects the update.
+        const existingModel = existing?.model ?? {};
+        const providerChanged = !!input.llm && input.llm.provider !== existingModel.provider;
+        // Provider-specific settings may not be valid for a new provider, so only
+        // the prompt and tools carry over when the provider changes.
+        const model = providerChanged
+            ? {
+                ...(existingModel.messages && { messages: existingModel.messages }),
+                ...(existingModel.toolIds && { toolIds: existingModel.toolIds }),
+            }
+            : { ...existingModel };
+        if (input.llm) {
+            model.provider = input.llm.provider;
+            model.model = input.llm.model;
         }
-    }
-    else {
-        if (input.toolIds && input.toolIds.length > 0) {
-            updateDto.model = { toolIds: input.toolIds };
+        if (hasToolIds) {
+            model.toolIds = input.toolIds;
         }
         if (input.instructions) {
-            if (!updateDto.model)
-                updateDto.model = {};
-            updateDto.model.messages = [
+            const otherMessages = (model.messages ?? []).filter((message) => message.role !== 'system');
+            model.messages = [
                 {
                     role: 'system',
                     content: input.instructions,
                 },
+                ...otherMessages,
             ];
         }
+        updateDto.model = model;
     }
     if (input.transcriber) {
         updateDto.transcriber = {
@@ -94,6 +96,8 @@ export function transformUpdateAssistantInput(input) {
     return updateDto;
 }
 export function transformAssistantOutput(assistant) {
+    const voiceModel = getAssistantVoiceModel(assistant.voice);
+    const transcriberModel = getAssistantTranscriberModel(assistant.transcriber);
     return {
         id: assistant.id,
         createdAt: assistant.createdAt,
@@ -106,11 +110,11 @@ export function transformAssistantOutput(assistant) {
         voice: {
             provider: assistant.voice?.provider || '11labs',
             voiceId: getAssistantVoiceId(assistant.voice),
-            model: getAssistantVoiceModel(assistant.voice) || 'eleven_turbo_v2_5',
+            ...(voiceModel ? { model: voiceModel } : {}),
         },
         transcriber: {
             provider: assistant.transcriber?.provider || 'deepgram',
-            model: getAssistantTranscriberModel(assistant.transcriber) || 'nova-3',
+            ...(transcriberModel ? { model: transcriberModel } : {}),
         },
         toolIds: assistant.model?.toolIds || [],
     };
@@ -245,13 +249,22 @@ export function transformToolInput(input) {
         default:
             throw new Error(`Unsupported tool type: ${input.type}`);
     }
+    if (input.additionalFields) {
+        Object.assign(toolDto, input.additionalFields);
+    }
     return toolDto;
 }
-export function transformUpdateToolInput(input) {
+export function transformUpdateToolInput(input, existing) {
     let updateDto = {};
+    // PATCH replaces `function` and `server` as a whole, so start from the
+    // tool's current values. Sending only the changed fields drops
+    // `function.name` and the API rejects the update.
+    const existingFunction = existing && 'function' in existing ? existing.function : undefined;
+    const existingServer = existing && 'server' in existing ? existing.server : undefined;
     // Add function definition if name and description are provided
     if (input.name || input.description) {
         updateDto.function = {
+            ...existingFunction,
             ...(input.name && { name: input.name }),
             ...(input.description && { description: input.description }),
         };
@@ -272,10 +285,12 @@ export function transformUpdateToolInput(input) {
         }
         else {
             updateDto.function = {
+                ...existingFunction,
                 parameters: input.function.parameters,
             };
         }
         updateDto.server = {
+            ...existingServer,
             url: input.function.server.url,
             ...(input.function.server.headers && { headers: input.function.server.headers }),
         };
@@ -295,20 +310,26 @@ export function transformUpdateToolInput(input) {
         if (input.apiRequest.timeoutSeconds)
             updateDto.timeoutSeconds = input.apiRequest.timeoutSeconds;
     }
+    if (input.additionalFields) {
+        Object.assign(updateDto, input.additionalFields);
+    }
     return updateDto;
 }
 export function transformToolOutput(tool) {
+    // Not every tool type in SDK 3.x has `function` or `server`.
+    const toolFunction = 'function' in tool ? tool.function : undefined;
+    const toolServer = 'server' in tool ? tool.server : undefined;
     return {
         id: tool.id,
         createdAt: tool.createdAt,
         updatedAt: tool.updatedAt,
         type: tool.type || '',
-        name: tool.function?.name || '',
-        description: tool.function?.description || '',
-        parameters: tool.function?.parameters || {},
+        name: toolFunction?.name || '',
+        description: toolFunction?.description || '',
+        parameters: toolFunction?.parameters || {},
         server: {
-            url: tool.server?.url || '',
-            headers: tool.server?.headers || {},
+            url: toolServer?.url || '',
+            headers: toolServer?.headers || {},
         }
     };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vapi-ai/mcp-server",
   "description": "Build AI voice assistants and phone agents with Vapi through the Model Context Protocol",
-  "version": "0.0.10",
+  "version": "0.1.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -32,12 +32,12 @@
     "tool-calling"
   ],
   "bin": {
-    "@vapi-ai/mcp-server": "dist/index.js"
+    "mcp-server": "dist/index.js"
   },
   "scripts": {
     "prepare": "npm run build",
     "clean": "shx rm -rf dist",
-    "build": "npm run clean && tsc -p tsconfig.build.json && shx chmod +x dist/*.js",
+    "build": "npm run clean && tsc -p tsconfig.build.json && shx cp src/schemas/assistant-openapi.json src/schemas/simulation-openapi.json dist/schemas/ && shx chmod +x dist/*.js",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "start": "node dist/index.js",
     "dev": "tsx watch src/index.ts",
@@ -49,6 +49,7 @@
     "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",
+    "schemas:snapshot": "node scripts/snapshot-assistant-validation.mjs",
     "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",
@@ -62,16 +63,18 @@
     "dist/**/*.d.ts.map"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.26.0",
-    "@vapi-ai/server-sdk": "^0.5.2",
+    "@modelcontextprotocol/sdk": "1.32.2",
+    "@vapi-ai/server-sdk": "^3.0.0",
     "dotenv": "^16.4.7",
-    "zod": "^3.25.76",
-    "zod-to-json-schema": "^3.24.5"
+    "yaml": "^2.9.1",
+    "zod": "4.6.7"
   },
   "devDependencies": {
     "@modelcontextprotocol/inspector": "1.0.1",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.14.0",
+    "ajv": "8.20.0",
+    "ajv-formats": "3.0.1",
     "jest": "^29.7.0",
     "shx": "^0.4.0",
     "ts-jest": "^29.3.1",