@vapi-ai/mcp-server 0.0.11 → 0.1.0

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAwD,gBAAgB,EAAsH,MAAM,wBAAwB,CAAC;AAEpO,eAAO,MAAM,gBAAgB,gCAAe,CAAC;AAI7C,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;AAa/E,eAAO,MAAM,WAAW;;;CAGvB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC,UAAU,CAAC,CAAC;AAE7E,eAAO,MAAM,aAAa;cACF,iBAAiB;;CAExC,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;CAG/B,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;CAMrB,CAAC;AAIX,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAC;AAIH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BrC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;iBAgBhC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;iBAElC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwBrC,CAAC;AAIH,eAAO,MAAM,eAAe;;;;;;;;;;iBA4B1B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;iBAW3B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;iBAE7B,CAAC;AAIH,eAAO,MAAM,yBAAyB;;iBAEpC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;iBAUlC,CAAC;AAIH,eAAO,MAAM,kBAAkB;;iBAE7B,CAAC;AAqEH,eAAO,MAAM,qBAAqB;;;;;;;;;;kBAnEqB,QAAQ;oBAAU,MAAM;wBAAc,MAAM;uBAAa,MAAM;0BAAgB,MAAM;;kBAArF,QAAQ;oBAAU,MAAM;wBAAc,MAAM;uBAAa,MAAM;0BAAgB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;iBAgFxI,CAAC;AAEL,eAAO,MAAM,qBAAqB;;;;;;;;;;kBAlFqB,QAAQ;oBAAU,MAAM;wBAAc,MAAM;uBAAa,MAAM;0BAAgB,MAAM;;kBAArF,QAAQ;oBAAU,MAAM;wBAAc,MAAM;uBAAa,MAAM;0BAAgB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;iBAoF1I,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;iBAQ3B,CAAC;AAIH,eAAO,MAAM,uBAAuB;;;iBAalC,CAAC;AAEH,cAAc,iBAAiB,CAAC"}

package/dist/schemas/index.js

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+import { CreateAssistantNameSchema, UpdateAssistantNameSchema, VoiceInputSchema, TranscriberInputSchema, LLMInputSchema, apiField, apiObjectField, requiredToolConfigurations, functionRequiresName } from './assistant-openapi.js';
+export const EmptyInputSchema = z.object({});
 // ===== Model Provider and Models =====
 export const ModelProvider = {
     OpenAI: 'openai',
@@ -19,58 +21,22 @@ export const GoogleModels = {
     Gemini2Flash: 'gemini-2.0-flash',
     Gemini2Pro: 'gemini-2.0-pro',
 };
-const OpenAILLMSchema = z.object({
-    provider: z.literal(ModelProvider.OpenAI),
-    model: z.enum([OpenAIModels.GPT4o, OpenAIModels.GPT4oMini]),
-});
-const AnthropicLLMSchema = z.object({
-    provider: z.literal(ModelProvider.Anthropic),
-    model: z.enum([
-        AnthropicModels.Claude3Sonnet,
-        AnthropicModels.Claude3Haiku,
-    ]),
-});
-const GoogleLLMSchema = z.object({
-    provider: z.literal(ModelProvider.GoogleAI),
-    model: z.enum([
-        GoogleModels.GeminiPro,
-        GoogleModels.GeminiFlash,
-        GoogleModels.Gemini2Flash,
-        GoogleModels.Gemini2Pro,
-    ]),
-});
-const GenericLLMSchema = z.object({
-    provider: z.string(),
-    model: z.string(),
-});
 const LLMSchema = z.union([
-    OpenAILLMSchema,
-    AnthropicLLMSchema,
-    GoogleLLMSchema,
-    GenericLLMSchema,
+    LLMInputSchema,
+    z.string().transform((value, ctx) => {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            ctx.addIssue({ code: 'custom', message: 'Invalid JSON. Provide an LLM object or a valid JSON object string.' });
+            return z.NEVER;
+        }
+    }).pipe(LLMInputSchema),
 ]);
 export const DEFAULT_LLM = {
     provider: ModelProvider.OpenAI,
     model: OpenAIModels.GPT4o,
 };
-const VoiceProviderSchema = z.enum([
-    'vapi',
-    '11labs',
-    'azure',
-    'cartesia',
-    'custom-voice',
-    'deepgram',
-    '11labs',
-    'hume',
-    'lmnt',
-    'neuphonic',
-    'openai',
-    'playht',
-    'rime-ai',
-    'smallest-ai',
-    'tavus',
-    'sesame',
-]);
 export const DEFAULT_VOICE = {
     provider: '11labs',
     voiceId: 'sarah',
@@ -94,58 +60,31 @@ export const BaseResponseSchema = z.object({
 });
 // ===== Assistant Schemas =====
 export const CreateAssistantInputSchema = z.object({
-    name: z.string().describe('Name of the assistant'),
-    instructions: z
-        .string()
+    name: CreateAssistantNameSchema.describe('Name of the assistant'),
+    instructions: apiField('instructions', { nullable: false })
         .optional()
         .default('You are a helpful assistant.')
         .describe('Instructions for the assistant'),
-    llm: z
-        .union([
-        LLMSchema,
-        z.string().transform((str) => {
-            try {
-                return JSON.parse(str);
-            }
-            catch (e) {
-                throw new Error(`Invalid LLM JSON string: ${str}`);
-            }
-        }),
-    ])
+    llm: LLMSchema
         .default(DEFAULT_LLM)
         .describe('LLM configuration'),
-    toolIds: z
-        .array(z.string())
+    toolIds: apiField('toolIds')
         .optional()
         .describe('IDs of tools to use with this assistant'),
-    transcriber: z
-        .object({
-        provider: z.string().describe('Provider to use for transcription'),
-        model: z.string().describe('Transcription model to use'),
-    })
+    transcriber: TranscriberInputSchema
         .default(DEFAULT_TRANSCRIBER)
         .describe('Transcription configuration'),
-    voice: z
-        .object({
-        provider: VoiceProviderSchema.describe('Provider to use for voice'),
-        voiceId: z.string().describe('Voice ID to use'),
-        model: z.string().optional().describe('Voice model to use'),
-    })
+    voice: VoiceInputSchema
         .default(DEFAULT_VOICE)
         .describe('Voice configuration'),
-    firstMessage: z
-        .string()
+    firstMessage: apiField('firstMessage')
         .optional()
         .default('Hello, how can I help you today?')
         .describe('First message to say to the user'),
-    firstMessageMode: z
-        .enum([
-        'assistant-speaks-first',
-        'assistant-waits-for-user',
-        'assistant-speaks-first-with-model-generated-message',
-    ])
-        .default('assistant-speaks-first')
+    firstMessageMode: apiField('firstMessageMode')
         .optional()
+        // Keep the advertised default without applying it to omitted input (Zod 3 behavior).
+        .meta({ default: 'assistant-speaks-first' })
         .describe('This determines who speaks first, either assistant or user'),
 });
 export const AssistantOutputSchema = BaseResponseSchema.extend({
@@ -161,90 +100,58 @@ export const AssistantOutputSchema = BaseResponseSchema.extend({
     }),
     transcriber: z.object({
         provider: z.string(),
-        model: z.string(),
+        model: z.string().optional(),
     }),
     toolIds: z.array(z.string()).optional(),
 });
 export const GetAssistantInputSchema = z.object({
-    assistantId: z.string().describe('ID of the assistant to get'),
+    assistantId: apiField('assistantId').describe('ID of the assistant to get'),
 });
 export const UpdateAssistantInputSchema = z.object({
-    assistantId: z.string().describe('ID of the assistant to update'),
-    name: z.string().optional().describe('New name for the assistant'),
-    instructions: z
-        .string()
+    assistantId: apiField('assistantId').describe('ID of the assistant to update'),
+    name: UpdateAssistantNameSchema.optional().describe('New name for the assistant'),
+    instructions: apiField('instructions', { nullable: false })
         .optional()
         .describe('New instructions for the assistant'),
-    llm: z
-        .union([
-        LLMSchema,
-        z.string().transform((str) => {
-            try {
-                return JSON.parse(str);
-            }
-            catch (e) {
-                throw new Error(`Invalid LLM JSON string: ${str}`);
-            }
-        }),
-    ])
+    llm: LLMSchema
         .optional()
         .describe('New LLM configuration'),
-    toolIds: z
-        .array(z.string())
+    toolIds: apiField('toolIds')
         .optional()
         .describe('New IDs of tools to use with this assistant'),
-    transcriber: z
-        .object({
-        provider: z.string().describe('Provider to use for transcription'),
-        model: z.string().describe('Transcription model to use'),
-    })
+    transcriber: TranscriberInputSchema
         .optional()
         .describe('New transcription configuration'),
-    voice: z
-        .object({
-        provider: VoiceProviderSchema.describe('Provider to use for voice'),
-        voiceId: z.string().describe('Voice ID to use'),
-        model: z.string().optional().describe('Voice model to use'),
-    })
+    voice: VoiceInputSchema
         .optional()
         .describe('New voice configuration'),
-    firstMessage: z
-        .string()
+    firstMessage: apiField('firstMessage')
         .optional()
         .describe('First message to say to the user'),
-    firstMessageMode: z
-        .enum([
-        'assistant-speaks-first',
-        'assistant-waits-for-user',
-        'assistant-speaks-first-with-model-generated-message',
-    ])
+    firstMessageMode: apiField('firstMessageMode')
         .optional()
         .describe('This determines who speaks first, either assistant or user'),
 });
 // ===== Call Schemas =====
 export const CallInputSchema = z.object({
-    assistantId: z
-        .string()
+    assistantId: apiField('callAssistantId')
         .optional()
         .describe('ID of the assistant to use for the call'),
-    phoneNumberId: z
-        .string()
+    phoneNumberId: apiField('callPhoneNumberId')
         .optional()
         .describe('ID of the phone number to use for the call'),
     customer: z
         .object({
-        number: z.string().describe('Customer phone number'),
+        number: apiField('customerNumber').describe('Customer phone number'),
     })
         .optional()
         .describe('Customer information'),
-    scheduledAt: z
-        .string()
+    scheduledAt: apiField('scheduledAt')
         .optional()
         .describe('ISO datetime string for when the call should be scheduled (e.g. "2025-03-25T22:39:27.771Z")'),
     assistantOverrides: z
         .object({
-        variableValues: z
-            .record(z.string(), z.any())
+        variableValues: apiField('variableValues')
             .optional()
             .describe('Key-value pairs for dynamic variables to use in the assistant\'s prompts (e.g. {"name": "Joe", "age": "24"})'),
     })
@@ -264,11 +171,11 @@ export const CallOutputSchema = BaseResponseSchema.extend({
     scheduledAt: z.string().optional(),
 });
 export const GetCallInputSchema = z.object({
-    callId: z.string().describe('ID of the call to get'),
+    callId: apiField('callId').describe('ID of the call to get'),
 });
 // ===== Phone Number Schemas =====
 export const GetPhoneNumberInputSchema = z.object({
-    phoneNumberId: z.string().describe('ID of the phone number to get'),
+    phoneNumberId: apiField('phoneNumberId').describe('ID of the phone number to get'),
 });
 export const PhoneNumberOutputSchema = BaseResponseSchema.extend({
     name: z.string().optional(),
@@ -283,43 +190,30 @@ export const PhoneNumberOutputSchema = BaseResponseSchema.extend({
 });
 // ===== Tool Schemas =====
 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(),
+    toolId: apiField('toolId').describe('ID of the tool to get'),
 });
+const TransferCallDestinationSchema = apiField('transferDestination', { additionalProperties: true })
+    .describe('Transfer destination. Other TransferDestinationNumber fields, such as transferPlan and message, are sent as given (see get_api_schema).');
+const FunctionParametersSchema = apiObjectField('functionParameters');
+const ApiBodySchema = apiObjectField('apiBody');
+// URLs and string-valued headers are retained MCP transport constraints where
+// the published DTO describes only a string/object. They are not copied API rules.
+const HeaderMapSchema = apiField('serverHeaders').pipe(z.record(z.string(), z.string()))
+    .meta({ type: 'object', additionalProperties: { type: 'string' } });
 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'),
+    url: apiField('serverUrl').pipe(z.string().url()).meta({ format: 'uri' }).describe('Server URL where the function will be called'),
+    headers: HeaderMapSchema.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'),
+    type: apiField('backoffType').default('fixed'),
+    maxRetries: apiField('backoffMaxRetries').default(3).describe('Maximum number of retries'),
+    baseDelaySeconds: apiField('backoffDelay').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'),
+    name: apiField('functionName').optional().describe('Name of the function/tool'),
+    description: apiField('functionDescription').optional().describe('Description of what the function/tool does'),
     // SMS tool configuration
     sms: z.object({
         metadata: z.object({
@@ -332,25 +226,42 @@ const BaseToolConfigSchema = z.object({
     }).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'),
+        parameters: FunctionParametersSchema.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'),
+        url: apiField('apiUrl').pipe(z.string().url()).meta({ format: 'uri' }).describe('URL to make the API request to'),
+        method: apiField('apiMethod').default('POST').describe('HTTP method for the API request'),
+        headers: HeaderMapSchema.optional().describe('Headers to send with the request (key-value pairs)'),
+        body: ApiBodySchema.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'),
+        timeoutSeconds: apiField('apiTimeout').default(20).describe('Request timeout in seconds'),
     }).optional().describe('API Request tool configuration - for HTTP API integration'),
+    // Documented fields the options above don't cover
+    additionalFields: z
+        .record(z.string(), z.any())
+        .optional()
+        .describe('Other top-level fields from the Vapi API for this tool type, such as messages or rejectionPlan, sent as given. ' +
+        'Look them up with get_api_schema, e.g. CreateTransferCallToolDTO. ' +
+        'On update_tool, each field given here replaces that whole field.'),
 });
 export const CreateToolInputSchema = BaseToolConfigSchema.extend({
-    type: z.enum(['sms', 'transferCall', 'function', 'apiRequest'])
+    type: apiField('toolType')
         .describe('Type of the tool to create'),
-});
+}).superRefine((input, ctx) => {
+    if (requiredToolConfigurations.includes(input.type) && !input[input.type]) {
+        ctx.addIssue({ code: 'custom', path: [input.type], message: 'This configuration is required for the selected tool type.' });
+    }
+    if (functionRequiresName && input.type === 'function' && (input.function || input.description) && !input.name) {
+        ctx.addIssue({ code: 'custom', path: ['name'], message: 'A function name is required when providing a function definition.' });
+    }
+}).meta({ allOf: [
+        ...requiredToolConfigurations.map(type => ({ if: { properties: { type: { const: type } }, required: ['type'] }, then: { required: [type] } })),
+        ...(functionRequiresName ? [{ if: { properties: { type: { const: 'function' } }, required: ['type'], anyOf: [{ required: ['function'] }, { required: ['description'], properties: { description: { minLength: 1 } } }] }, then: { required: ['name'] } }] : []),
+    ] });
 export const UpdateToolInputSchema = BaseToolConfigSchema.extend({
-    toolId: z.string().describe('ID of the tool to update'),
+    toolId: apiField('toolId').describe('ID of the tool to update'),
 });
 export const ToolOutputSchema = BaseResponseSchema.extend({
     type: z
@@ -358,6 +269,18 @@ export const ToolOutputSchema = BaseResponseSchema.extend({
         .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'),
+    parameters: z.record(z.string(), z.any()).describe('Parameters of the tool'),
     server: ServerSchema.describe('Server of the tool'),
 });
+// ===== API Schema Lookup =====
+export const GetApiSchemaInputSchema = z.object({
+    name: z
+        .string()
+        .optional()
+        .describe('Exact schema name to return, e.g. "CreateTransferCallToolDTO" or "TransferPlan"'),
+    search: z
+        .string()
+        .optional()
+        .describe('Case-insensitive text to find schema names, e.g. "transfer". Used when name is not given.'),
+});
+export * from './simulation.js';

package/dist/schemas/simulation-openapi.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+type JsonSchema = z.core.JSONSchema.JSONSchema;
+export declare function simulationContract(name: string): JsonSchema;
+export declare function simulationValidator(name: string): z.ZodType;
+export declare function simulationParameter<T>(name: string): z.ZodType<T>;
+export declare function simulationField<T>(dto: string, field: string): z.ZodType<T>;
+export declare function validateSimulationBody(dto: string, input: Record<string, unknown>, ctx: z.RefinementCtx): void;
+export {};
+//# sourceMappingURL=simulation-openapi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"simulation-openapi.d.ts","sourceRoot":"","sources":["../../src/schemas/simulation-openapi.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,KAAK,UAAU,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;AAQ/C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAK3D;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAO3D;AAkCD,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAEjE;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAS3E;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,aAAa,QAQvG"}

package/dist/schemas/simulation-openapi.js

@@ -0,0 +1,81 @@
+import { readFileSync } from 'node:fs';
+import { z } from 'zod';
+import { inputContract } from './assistant-openapi.js';
+const snapshot = JSON.parse(readFileSync(new URL('./simulation-openapi.json', import.meta.url), 'utf8'));
+export function simulationContract(name) {
+    const schema = snapshot.schemas[name] ?? snapshot.parameters[name] ?? snapshot.definitions[name];
+    if (!schema)
+        throw new Error(`Unknown simulation contract: ${name}`);
+    return JSON.parse(JSON.stringify(inputContract({ ...schema, definitions: snapshot.definitions }), (key, value) => key === '$ref' && typeof value === 'string' ? value.replace('#/components/schemas/', '#/definitions/') : value));
+}
+const validators = new Map();
+export function simulationValidator(name) {
+    let validator = validators.get(name);
+    if (!validator) {
+        validator = z.fromJSONSchema(simulationContract(name), { defaultTarget: 'openapi-3.0' });
+        validators.set(name, validator);
+    }
+    return validator;
+}
+// Full assistant/structured-output DTOs expand to hundreds of MB if converted
+// back to inline tool JSON. Advertise compact object envelopes for these fields,
+// while validating their complete published contracts at the same boundary.
+function compact(schema) {
+    if (typeof schema === 'boolean')
+        return schema;
+    if (schema.$ref) {
+        const name = schema.$ref.split('/').at(-1);
+        return compact(inputContract(snapshot.definitions[name]));
+    }
+    const result = { ...schema };
+    delete result.definitions;
+    for (const key of ['allOf', 'oneOf', 'anyOf']) {
+        if (result[key])
+            result[key] = result[key].map(compact);
+    }
+    if (result.items && !Array.isArray(result.items))
+        result.items = compact(result.items);
+    if (result.properties)
+        result.properties = Object.fromEntries(Object.entries(result.properties).map(([key, value]) => [key,
+            ['assistant', 'structuredOutput', 'targetOverrides'].includes(key)
+                ? { type: 'object', additionalProperties: true, description: `Full ${key} configuration, validated against the bundled Vapi OpenAPI schema. See https://api.vapi.ai/api-json.` }
+                : compact(value),
+        ]));
+    return result;
+}
+function advertised(validator, contract) {
+    return z.any().superRefine((value, ctx) => {
+        const result = validator.safeParse(value);
+        if (!result.success)
+            for (const issue of result.error.issues)
+                ctx.addIssue({ ...issue });
+        // Preserve the submitted payload: imported defaults are annotations and
+        // unknown documented extension fields must not disappear during parsing.
+    }).meta(compact(contract));
+}
+export function simulationParameter(name) {
+    return advertised(simulationValidator(name), simulationContract(name));
+}
+export function simulationField(dto, field) {
+    const validator = simulationValidator(dto);
+    if (!(validator instanceof z.ZodObject))
+        throw new Error(`${dto} must be an object schema`);
+    const contract = simulationContract(dto).properties?.[field];
+    if (!contract || !validator.shape[field])
+        throw new Error(`Missing simulation field: ${dto}.${field}`);
+    const result = advertised(validator.shape[field], field === 'assistant'
+        ? { type: 'object', additionalProperties: true, description: 'Full tester assistant configuration, validated against the bundled Vapi OpenAPI schema. See https://api.vapi.ai/api-json (TransientAssistantDTO).' }
+        : contract);
+    return simulationContract(dto).required?.includes(field) ? result : result.optional();
+}
+export function validateSimulationBody(dto, input, ctx) {
+    const { additionalFields, ...fields } = input;
+    const extra = additionalFields;
+    const result = simulationValidator(dto).safeParse({ ...fields, ...extra });
+    if (!result.success)
+        for (const issue of result.error.issues)
+            ctx.addIssue({
+                ...issue,
+                path: extra && Object.hasOwn(extra, issue.path[0]) ? ['additionalFields', ...issue.path] : issue.path,
+            });
+}