@vapi-ai/mcp-server 0.0.11 → 0.1.0

package/dist/schemas/simulation.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+export declare const ListSimulationResourcesInputSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodPipe<z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>, z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const ListSimulationScenariosInputSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodPipe<z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>, z.ZodNumber>>;
+    name: z.ZodOptional<z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>>;
+}, z.core.$strip>;
+export declare const CreateSimulationPersonalityInputSchema: z.ZodObject<{
+    name: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    assistant: z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>;
+    path: z.ZodType<string | null | undefined, unknown, z.core.$ZodTypeInternals<string | null | undefined, unknown>>;
+}, z.core.$strip>;
+export declare const CreateSimulationScenarioInputSchema: z.ZodObject<{
+    name: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    instructions: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    evaluations: z.ZodType<Record<string, unknown>[], unknown, z.core.$ZodTypeInternals<Record<string, unknown>[], unknown>>;
+    path: z.ZodType<string | null | undefined, unknown, z.core.$ZodTypeInternals<string | null | undefined, unknown>>;
+    additionalFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const CreateSimulationInputSchema: z.ZodObject<{
+    scenarioId: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    personalityId: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    name: z.ZodType<string | undefined, unknown, z.core.$ZodTypeInternals<string | undefined, unknown>>;
+    path: z.ZodType<string | null | undefined, unknown, z.core.$ZodTypeInternals<string | null | undefined, unknown>>;
+}, z.core.$strip>;
+export declare const CreateSimulationSuiteInputSchema: z.ZodObject<{
+    name: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    simulationIds: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    path: z.ZodType<string | null | undefined, unknown, z.core.$ZodTypeInternals<string | null | undefined, unknown>>;
+    additionalFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const RunSimulationsInputSchema: z.ZodObject<{
+    assistantId: z.ZodOptional<z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>>;
+    squadId: z.ZodOptional<z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>>;
+    simulationIds: z.ZodOptional<z.ZodArray<z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>>>;
+    suiteIds: z.ZodOptional<z.ZodArray<z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>>>;
+    iterations: z.ZodOptional<z.ZodPipe<z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>, z.ZodNumber>>;
+    transport: z.ZodOptional<z.ZodType<"vapi.websocket" | "vapi.webchat", unknown, z.core.$ZodTypeInternals<"vapi.websocket" | "vapi.webchat", unknown>>>;
+    idempotencyKey: z.ZodOptional<z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>>;
+}, z.core.$strip>;
+export declare const ListSimulationRunsInputSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodPipe<z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>, z.ZodNumber>>;
+    status: z.ZodOptional<z.ZodType<"queued" | "running" | "ended", unknown, z.core.$ZodTypeInternals<"queued" | "running" | "ended", unknown>>>;
+    targetId: z.ZodOptional<z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>>;
+}, z.core.$strip>;
+export declare const GetSimulationRunInputSchema: z.ZodObject<{
+    runId: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+}, z.core.$strip>;
+export declare const GetSimulationRunItemInputSchema: z.ZodObject<{
+    runId: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    itemId: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+}, z.core.$strip>;
+//# sourceMappingURL=simulation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"simulation.d.ts","sourceRoot":"","sources":["../../src/schemas/simulation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,kCAAkC;;iBAAsB,CAAC;AACtE,eAAO,MAAM,kCAAkC;;;iBAE7C,CAAC;AAEH,eAAO,MAAM,sCAAsC;;;;iBAIjD,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;;;;iBAQ9C,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;iBAKtC,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;iBAO3C,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;iBAsBlC,CAAC;AAEL,eAAO,MAAM,6BAA6B;;;;iBAGxC,CAAC;AACH,eAAO,MAAM,2BAA2B;;iBAAkD,CAAC;AAE3F,eAAO,MAAM,+BAA+B;;;iBAE1C,CAAC"}

package/dist/schemas/simulation.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { simulationField as field, simulationParameter as parameter, validateSimulationBody } from './simulation-openapi.js';
+// Limits of 1–100 integers and a default of 50 are the compact MCP paging
+// policy; the API's imported range is 0–1000. Keep that policy explicit.
+const limit = parameter('limit').pipe(z.number().int().min(1).max(100)).optional()
+    .describe('Maximum number of results to return (default 50)');
+const additionalFields = z.record(z.string(), z.unknown()).optional()
+    .describe('Additional documented API fields. The merged request is validated against the bundled Vapi OpenAPI schema.');
+export const ListSimulationResourcesInputSchema = z.object({ limit });
+export const ListSimulationScenariosInputSchema = z.object({
+    limit, name: parameter('scenarioName').optional(),
+});
+export const CreateSimulationPersonalityInputSchema = z.object({
+    name: field('CreatePersonalityDTO', 'name'),
+    assistant: field('CreatePersonalityDTO', 'assistant'),
+    path: field('CreatePersonalityDTO', 'path'),
+});
+export const CreateSimulationScenarioInputSchema = z.object({
+    name: field('CreateScenarioDTO', 'name'),
+    instructions: field('CreateScenarioDTO', 'instructions'),
+    evaluations: field('CreateScenarioDTO', 'evaluations'),
+    path: field('CreateScenarioDTO', 'path'),
+    additionalFields,
+}).superRefine((input, ctx) => {
+    if (input.additionalFields)
+        validateSimulationBody('CreateScenarioDTO', input, ctx);
+});
+export const CreateSimulationInputSchema = z.object({
+    scenarioId: field('CreateSimulationDTO', 'scenarioId'),
+    personalityId: field('CreateSimulationDTO', 'personalityId'),
+    name: field('CreateSimulationDTO', 'name'),
+    path: field('CreateSimulationDTO', 'path'),
+});
+export const CreateSimulationSuiteInputSchema = z.object({
+    name: field('CreateSimulationSuiteDTO', 'name'),
+    simulationIds: field('CreateSimulationSuiteDTO', 'simulationIds'),
+    path: field('CreateSimulationSuiteDTO', 'path'),
+    additionalFields,
+}).superRefine((input, ctx) => {
+    if (input.additionalFields)
+        validateSimulationBody('CreateSimulationSuiteDTO', input, ctx);
+});
+export const RunSimulationsInputSchema = z.object({
+    assistantId: field('SimulationRunTargetAssistant', 'assistantId').optional(),
+    squadId: field('SimulationRunTargetSquad', 'squadId').optional(),
+    simulationIds: z.array(field('SimulationRunSimulationEntry', 'simulationId')).optional(),
+    suiteIds: z.array(field('SimulationRunSuiteEntry', 'simulationSuiteId')).optional(),
+    // The integral iteration count is an MCP adapter rule; bounds come from API.
+    iterations: field('CreateSimulationRunDTO', 'iterations').pipe(z.number().int()).optional(),
+    transport: field('SimulationRunTransportConfiguration', 'provider').optional(),
+    idempotencyKey: parameter('idempotencyKey').optional(),
+}).superRefine((input, ctx) => {
+    if (!!input.assistantId === !!input.squadId)
+        ctx.addIssue({
+            code: 'custom', path: ['assistantId'], message: 'Give exactly one of assistantId or squadId.',
+        });
+    if (!(input.simulationIds?.length || input.suiteIds?.length))
+        ctx.addIssue({
+            code: 'custom', path: ['simulationIds'], message: 'Give at least one simulationId or suiteId.',
+        });
+}).meta({ allOf: [
+        { oneOf: [{ required: ['assistantId'] }, { required: ['squadId'] }] },
+        { anyOf: [
+                { required: ['simulationIds'], properties: { simulationIds: { minItems: 1 } } },
+                { required: ['suiteIds'], properties: { suiteIds: { minItems: 1 } } },
+            ] },
+    ] });
+export const ListSimulationRunsInputSchema = z.object({
+    limit, status: parameter('runStatus').optional(),
+    targetId: parameter('targetId').optional(),
+});
+export const GetSimulationRunInputSchema = z.object({ runId: parameter('runId') });
+// The item endpoint publishes plain strings, unlike the run endpoint's UUID.
+export const GetSimulationRunItemInputSchema = z.object({
+    runId: parameter('itemRunId'), itemId: parameter('itemId'),
+});

package/dist/tools/api-schema.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { VapiClient } from '@vapi-ai/server-sdk';
+export declare const registerApiSchemaTools: (server: McpServer, vapiClient: VapiClient) => void;
+//# sourceMappingURL=api-schema.d.ts.map

package/dist/tools/api-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-schema.d.ts","sourceRoot":"","sources":["../../src/tools/api-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAmB,MAAM,qBAAqB,CAAC;AAkElE,eAAO,MAAM,sBAAsB,GACjC,QAAQ,SAAS,EACjB,YAAY,UAAU,SAuCvB,CAAC"}

package/dist/tools/api-schema.js

@@ -0,0 +1,67 @@
+import { VapiEnvironment } from '@vapi-ai/server-sdk';
+import { GetApiSchemaInputSchema } from '../schemas/index.js';
+import { createToolHandler } from './utils.js';
+// The OpenAPI spec is about 2 MB, so load it once per client and keep only
+// its schemas. It is fetched through the client so it comes from the same
+// API environment the other tools call.
+const schemaCache = new WeakMap();
+// vapiClient.fetch resolves relative paths only against an explicitly
+// configured base URL, so resolve it the way the SDK's own resource clients
+// do: baseUrl, then environment, then the default API host.
+async function resolveBaseUrl(vapiClient) {
+    const options = vapiClient._options;
+    const get = async (supplier) => typeof supplier === 'function' ? await supplier() : supplier;
+    return ((await get(options?.baseUrl)) ??
+        (await get(options?.environment)) ??
+        VapiEnvironment.Default);
+}
+function loadSchemas(vapiClient) {
+    let schemas = schemaCache.get(vapiClient);
+    if (!schemas) {
+        schemas = resolveBaseUrl(vapiClient)
+            .then((baseUrl) => vapiClient.fetch(`${baseUrl.replace(/\/+$/, '')}/api-json`))
+            .then(async (response) => {
+            if (!response.ok) {
+                throw new Error(`Could not load the Vapi API schema: HTTP ${response.status}`);
+            }
+            const spec = (await response.json());
+            return spec.components?.schemas ?? {};
+        });
+        // Let the next call retry after a failed load.
+        schemas.catch(() => schemaCache.delete(vapiClient));
+        schemaCache.set(vapiClient, schemas);
+    }
+    return schemas;
+}
+function findSchemaNames(schemas, text) {
+    const needle = text.toLowerCase();
+    return Object.keys(schemas)
+        .filter((name) => name.toLowerCase().includes(needle))
+        .sort();
+}
+const MAX_MATCHES = 50;
+export const registerApiSchemaTools = (server, vapiClient) => {
+    server.registerTool('get_api_schema', {
+        description: 'Looks up a schema in the Vapi API reference (the OpenAPI spec the Vapi SDKs are generated from). ' +
+            'Pass `search` to find schema names, then `name` to get one schema. ' +
+            'References to other schemas are left as "#/components/schemas/<Name>" and listed in referencedSchemas, so look those up next if you need them. ' +
+            'Use it to find fields that other tools accept through additionalFields.',
+        inputSchema: GetApiSchemaInputSchema.shape,
+    }, createToolHandler(async (data) => {
+        const schemas = await loadSchemas(vapiClient);
+        if (data.name) {
+            const schema = schemas[data.name];
+            if (!schema) {
+                const similar = findSchemaNames(schemas, data.name).slice(0, 10);
+                throw new Error(`No schema named ${data.name}.` +
+                    (similar.length > 0 ? ` Similar names: ${similar.join(', ')}` : ''));
+            }
+            const referencedSchemas = [
+                ...new Set(Array.from(JSON.stringify(schema).matchAll(/#\/components\/schemas\/([\w.-]+)/g), (match) => match[1])),
+            ];
+            return { name: data.name, schema, referencedSchemas };
+        }
+        const matches = findSchemaNames(schemas, data.search ?? '');
+        return { matches: matches.slice(0, MAX_MATCHES), total: matches.length };
+    }));
+};

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,SA6EvB,CAAC"}
+{"version":3,"file":"assistant.d.ts","sourceRoot":"","sources":["../../src/tools/assistant.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAQ,MAAM,qBAAqB,CAAC;AAcvD,eAAO,MAAM,sBAAsB,GACjC,QAAQ,SAAS,EACjB,YAAY,UAAU,SA4FvB,CAAC"}

package/dist/tools/assistant.js

@@ -1,27 +1,34 @@
-import { CreateAssistantInputSchema, GetAssistantInputSchema, UpdateAssistantInputSchema, } from '../schemas/index.js';
+import { registerValidatedTool } from './validation.js';
+import { EmptyInputSchema, CreateAssistantInputSchema, GetAssistantInputSchema, UpdateAssistantInputSchema, } from '../schemas/index.js';
 import { transformAssistantInput, transformAssistantOutput, transformUpdateAssistantInput, } from '../transformers/index.js';
 import { createToolHandler } from './utils.js';
 export const registerAssistantTools = (server, vapiClient) => {
-    server.registerTool('list_assistants', {
+    registerValidatedTool(server, 'list_assistants', {
         description: 'Lists all Vapi assistants',
-        inputSchema: {},
+        inputSchema: EmptyInputSchema,
     }, createToolHandler(async () => {
         //   console.log('list_assistants');
         const assistants = await vapiClient.assistants.list({ limit: 10 });
         //   console.log('assistants', assistants);
         return assistants.map(transformAssistantOutput);
     }));
-    server.tool('create_assistant', 'Creates a new Vapi assistant', CreateAssistantInputSchema.shape, createToolHandler(async (data) => {
+    registerValidatedTool(server, 'create_assistant', {
+        description: 'Creates a new Vapi assistant',
+        inputSchema: CreateAssistantInputSchema,
+    }, createToolHandler(async (data) => {
         //   console.log('create_assistant', data);
         const createAssistantDto = transformAssistantInput(data);
         const assistant = await vapiClient.assistants.create(createAssistantDto);
         return transformAssistantOutput(assistant);
     }));
-    server.tool('get_assistant', 'Gets a Vapi assistant by ID', GetAssistantInputSchema.shape, createToolHandler(async (data) => {
+    registerValidatedTool(server, 'get_assistant', {
+        description: 'Gets a Vapi assistant by ID',
+        inputSchema: GetAssistantInputSchema,
+    }, createToolHandler(async (data) => {
         //   console.log('get_assistant', data);
         const assistantId = data.assistantId;
         try {
-            const assistant = await vapiClient.assistants.get(assistantId);
+            const assistant = await vapiClient.assistants.get({ id: assistantId });
             if (!assistant) {
                 throw new Error(`Assistant with ID ${assistantId} not found`);
             }
@@ -32,18 +39,26 @@ export const registerAssistantTools = (server, vapiClient) => {
             throw error;
         }
     }));
-    server.tool('update_assistant', 'Updates an existing Vapi assistant', UpdateAssistantInputSchema.shape, createToolHandler(async (data) => {
+    registerValidatedTool(server, 'update_assistant', {
+        description: 'Updates an existing Vapi assistant',
+        inputSchema: UpdateAssistantInputSchema,
+    }, createToolHandler(async (data) => {
         const assistantId = data.assistantId;
         try {
             // First check if the assistant exists
-            const existingAssistant = await vapiClient.assistants.get(assistantId);
+            const existingAssistant = await vapiClient.assistants.get({
+                id: assistantId,
+            });
             if (!existingAssistant) {
                 throw new Error(`Assistant with ID ${assistantId} not found`);
             }
             // Transform the update data
-            const updateAssistantDto = transformUpdateAssistantInput(data);
+            const updateAssistantDto = transformUpdateAssistantInput(data, existingAssistant);
             // Update the assistant
-            const updatedAssistant = await vapiClient.assistants.update(assistantId, updateAssistantDto);
+            const updatedAssistant = await vapiClient.assistants.update({
+                ...updateAssistantDto,
+                id: assistantId,
+            });
             return transformAssistantOutput(updatedAssistant);
         }
         catch (error) {

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

package/dist/tools/call.js

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

package/dist/tools/docs.d.ts

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

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

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

package/dist/tools/docs.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { askVapiDocs } from '../knowledge/docs.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'}` }] };
+    }
+}
+export function registerDocsTools(server) {
+    const annotations = { readOnlyHint: true, destructiveHint: false, openWorldHint: true };
+    server.registerTool('ask_vapi_docs', {
+        description: 'Ask about current Vapi documentation through the Fern docs MCP. Returns relevant documentation passages and source URLs; use them to answer the question.',
+        inputSchema: {
+            question: z.string().trim().min(1).max(4000).describe('A specific question about Vapi configuration, APIs, SDKs or troubleshooting. Send no API keys or private customer data.'),
+            topK: z.number().int().min(1).max(20).default(8).describe('Maximum number of relevant documentation passages.'),
+        }, annotations,
+    }, ({ question, topK }, extra) => knowledgeResult(async () => {
+        const result = await askVapiDocs(question, topK, extra.signal);
+        // The upstream SDK also types legacy toolResult responses. Fern uses the
+        // normal content form, which is the only form this wrapper advertises.
+        if (!('content' in result))
+            throw new Error('Unexpected response from the Vapi docs MCP.');
+        return result;
+    }));
+}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAOjD,eAAO,MAAM,gBAAgB,GAAI,QAAQ,SAAS,EAAE,YAAY,UAAU,SAKzE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAWjD,eAAO,MAAM,gBAAgB,GAAI,QAAQ,SAAS,EAAE,YAAY,UAAU,SASzE,CAAC"}

package/dist/tools/index.js

@@ -1,10 +1,18 @@
+import { registerDocsTools } from './docs.js';
 import { registerAssistantTools } from './assistant.js';
 import { registerCallTools } from './call.js';
 import { registerPhoneNumberTools } from './phone-number.js';
+import { registerSimulationTools } from './simulation.js';
 import { registerToolTools } from './tool.js';
+import { registerSkillTools } from './skills.js';
+import { registerApiSchemaTools } from './api-schema.js';
 export const registerAllTools = (server, vapiClient) => {
+    registerDocsTools(server);
     registerAssistantTools(server, vapiClient);
     registerCallTools(server, vapiClient);
     registerPhoneNumberTools(server, vapiClient);
     registerToolTools(server, vapiClient);
+    registerApiSchemaTools(server, vapiClient);
+    registerSkillTools(server);
+    registerSimulationTools(server, vapiClient);
 };

package/dist/tools/input-schema.d.ts

@@ -0,0 +1,5 @@
+import type { z } from 'zod';
+type JsonSchema = z.core.JSONSchema.JSONSchema;
+export declare function summarizeInputSchema(schema: JsonSchema): JsonSchema;
+export {};
+//# sourceMappingURL=input-schema.d.ts.map

package/dist/tools/input-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-schema.d.ts","sourceRoot":"","sources":["../../src/tools/input-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,KAAK,UAAU,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;AAM/C,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAsCnE"}

package/dist/tools/input-schema.js

@@ -0,0 +1,59 @@
+// tools/list describes how to call a tool. Provider catalogs and recursive API
+// definitions belong in on-demand schema lookup, not every agent's tool context.
+// This projection is intentionally broader than the unchanged runtime validator.
+export function summarizeInputSchema(schema) {
+    const alternatives = schema.oneOf ?? schema.anyOf;
+    if (alternatives?.length && alternatives.every(branch => branch.type === 'object' && branch.properties?.provider)) {
+        const keys = [...new Set(alternatives.flatMap(branch => Object.keys(branch.properties)))];
+        return {
+            type: 'object',
+            properties: Object.fromEntries(keys.map(key => [key, typeSummary(alternatives.flatMap(branch => branch.properties?.[key] ? [branch.properties[key]] : []))])),
+            required: (alternatives[0].required ?? []).filter(key => alternatives.every(branch => branch.required?.includes(key))),
+            additionalProperties: false,
+            ...(schema.description ? { description: schema.description } : {}),
+        };
+    }
+    // Do not expand recursive JSON Schema definitions in the advertised contract.
+    // An empty schema accepts the value; the runtime validator still checks it.
+    if (schema.$ref)
+        return {};
+    const summary = {};
+    for (const [key, value] of Object.entries(schema)) {
+        // Dropping a negative constraint broadens discovery; simplifying its
+        // contents could instead reject values accepted by the runtime schema.
+        if (['definitions', '$defs', '$schema', 'title', 'example', 'examples', 'not'].includes(key))
+            continue;
+        if (key === 'description' && typeof value === 'string' && value.length > 180)
+            continue;
+        if (key === 'enum' && Array.isArray(value) && value.length > 8)
+            continue;
+        if (key === 'properties') {
+            summary.properties = Object.fromEntries(Object.entries(value)
+                .map(([name, field]) => [name, typeof field === 'boolean' ? field : summarizeInputSchema(field)]));
+        }
+        else if (['oneOf', 'anyOf', 'allOf'].includes(key)) {
+            // Relaxed branches can overlap, so discovery must not require exclusivity.
+            summary[key === 'oneOf' ? 'anyOf' : key] = value.map(summarizeInputSchema);
+        }
+        else if (['items', 'additionalProperties', 'then', 'else'].includes(key) && typeof value === 'object' && value !== null) {
+            summary[key] = summarizeInputSchema(value);
+        }
+        else {
+            summary[key] = value;
+        }
+    }
+    return summary;
+}
+function typeSummary(schemas) {
+    if (schemas.some(schema => typeof schema === 'boolean' || !schemaTypes(schema).length))
+        return {};
+    const types = [...new Set(schemas.flatMap(schemaTypes))];
+    return types.length === 1 ? { type: types[0] } : types.length ? { type: types } : {};
+}
+function schemaTypes(schema) {
+    if (typeof schema === 'boolean')
+        return [];
+    if (schema.type)
+        return Array.isArray(schema.type) ? schema.type : [schema.type];
+    return (schema.oneOf ?? schema.anyOf ?? []).flatMap(schemaTypes);
+}

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

package/dist/tools/phone-number.js

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

package/dist/tools/simulation.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { VapiClient } from '@vapi-ai/server-sdk';
+export declare const registerSimulationTools: (server: McpServer, vapiClient: VapiClient) => void;
+//# sourceMappingURL=simulation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"simulation.d.ts","sourceRoot":"","sources":["../../src/tools/simulation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAQ,MAAM,qBAAqB,CAAC;AA2CvD,eAAO,MAAM,uBAAuB,GAClC,QAAQ,SAAS,EACjB,YAAY,UAAU,SA6NvB,CAAC"}