@vapi-ai/mcp-server 0.0.7 → 0.0.9

package/README.md

@@ -77,6 +77,40 @@ I'd like to speak with my ShopHelper assistant to talk about my recent order. Ca
 I need to schedule a call with Mary assistant for next Tuesday at 3:00 PM. My phone number is +1555123456.
 ```
 
+**Example 3:** Make a call with dynamic variables
+
+```md
+I want to call +1234567890 with my appointment reminder assistant. Use these details:
+- Customer name: Sarah Johnson
+- Appointment date: March 25th
+- Appointment time: 2:30 PM
+- Doctor name: Dr. Smith
+```
+
+## Using Variable Values in Assistant Prompts
+
+The `create_call` action supports passing dynamic variables through `assistantOverrides.variableValues`. These variables can be used in your assistant's prompts using double curly braces: `{{variableName}}`.
+
+### Example Assistant Prompt with Variables
+
+```
+Hello {{customerName}}, this is a reminder about your appointment on {{appointmentDate}} at {{appointmentTime}} with {{doctorName}}.
+```
+
+### Default Variables
+
+The following variables are automatically available (no need to pass in variableValues):
+
+- `{{now}}` - Current date and time (UTC)
+- `{{date}}` - Current date (UTC)
+- `{{time}}` - Current time (UTC)
+- `{{month}}` - Current month (UTC)
+- `{{day}}` - Current day of month (UTC)
+- `{{year}}` - Current year (UTC)
+- `{{customer.number}}` - Customer's phone number
+
+For more details on default variables and advanced date/time formatting, see the [official Vapi documentation](https://docs.vapi.ai/assistants/dynamic-variables#default-variables).
+
 ## Remote MCP
 
 To connect to Vapi's MCP server remotely:
@@ -187,10 +221,12 @@ The Vapi MCP Server provides the following tools for integration:
 ### Call Tools
 
 - `list_calls`: Lists all Vapi calls
-- `create_call`: Creates an outbound call
+- `create_call`: Creates an outbound call with support for:
+  - Immediate or scheduled calls
+  - Dynamic variable values through `assistantOverrides`
 - `get_call`: Gets details of a specific call
 
-> **Note:** The `create_call` action supports scheduling calls for immediate execution or for a future time.
+> **Note:** The `create_call` action supports scheduling calls for immediate execution or for a future time. You can also pass dynamic variables using `assistantOverrides.variableValues` to personalize assistant messages.
 
 ### Phone Number Tools
 

package/dist/schemas/index.d.ts

@@ -371,27 +371,40 @@ export declare const CallInputSchema: z.ZodObject<{
     assistantId: z.ZodOptional<z.ZodString>;
     phoneNumberId: z.ZodOptional<z.ZodString>;
     customer: z.ZodOptional<z.ZodObject<{
-        phoneNumber: z.ZodString;
+        number: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        phoneNumber: string;
+        number: string;
     }, {
-        phoneNumber: string;
+        number: string;
     }>>;
     scheduledAt: z.ZodOptional<z.ZodString>;
+    assistantOverrides: z.ZodOptional<z.ZodObject<{
+        variableValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        variableValues?: Record<string, any> | undefined;
+    }, {
+        variableValues?: Record<string, any> | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     assistantId?: string | undefined;
     phoneNumberId?: string | undefined;
     customer?: {
-        phoneNumber: string;
+        number: string;
     } | undefined;
     scheduledAt?: string | undefined;
+    assistantOverrides?: {
+        variableValues?: Record<string, any> | undefined;
+    } | undefined;
 }, {
     assistantId?: string | undefined;
     phoneNumberId?: string | undefined;
     customer?: {
-        phoneNumber: string;
+        number: string;
     } | undefined;
     scheduledAt?: string | undefined;
+    assistantOverrides?: {
+        variableValues?: Record<string, any> | undefined;
+    } | undefined;
 }>;
 export declare const CallOutputSchema: z.ZodObject<z.objectUtil.extendShape<{
     id: z.ZodString;
@@ -403,11 +416,11 @@ export declare const CallOutputSchema: z.ZodObject<z.objectUtil.extendShape<{
     assistantId: z.ZodOptional<z.ZodString>;
     phoneNumberId: z.ZodOptional<z.ZodString>;
     customer: z.ZodOptional<z.ZodObject<{
-        phoneNumber: z.ZodString;
+        number: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        phoneNumber: string;
+        number: string;
     }, {
-        phoneNumber: string;
+        number: string;
     }>>;
     scheduledAt: z.ZodOptional<z.ZodString>;
 }>, "strip", z.ZodTypeAny, {
@@ -418,7 +431,7 @@ export declare const CallOutputSchema: z.ZodObject<z.objectUtil.extendShape<{
     assistantId?: string | undefined;
     phoneNumberId?: string | undefined;
     customer?: {
-        phoneNumber: string;
+        number: string;
     } | undefined;
     scheduledAt?: string | undefined;
     endedReason?: string | undefined;
@@ -430,7 +443,7 @@ export declare const CallOutputSchema: z.ZodObject<z.objectUtil.extendShape<{
     assistantId?: string | undefined;
     phoneNumberId?: string | undefined;
     customer?: {
-        phoneNumber: string;
+        number: string;
     } | undefined;
     scheduledAt?: string | undefined;
     endedReason?: string | undefined;
@@ -497,6 +510,772 @@ export declare const GetToolInputSchema: z.ZodObject<{
 }, {
     toolId: string;
 }>;
+export declare const CreateToolInputSchema: z.ZodObject<z.objectUtil.extendShape<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    sms: z.ZodOptional<z.ZodObject<{
+        metadata: z.ZodObject<{
+            from: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+        }, {
+            from: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        metadata: {
+            from: string;
+        };
+    }, {
+        metadata: {
+            from: string;
+        };
+    }>>;
+    transferCall: z.ZodOptional<z.ZodObject<{
+        destinations: z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"number">;
+            number: z.ZodString;
+            extension: z.ZodOptional<z.ZodString>;
+            callerId: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            number: string;
+            type: "number";
+            extension?: string | undefined;
+            callerId?: string | undefined;
+            description?: string | undefined;
+        }, {
+            number: string;
+            type: "number";
+            extension?: string | undefined;
+            callerId?: string | undefined;
+            description?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        destinations: {
+            number: string;
+            type: "number";
+            extension?: string | undefined;
+            callerId?: string | undefined;
+            description?: string | undefined;
+        }[];
+    }, {
+        destinations: {
+            number: string;
+            type: "number";
+            extension?: string | undefined;
+            callerId?: string | undefined;
+            description?: string | undefined;
+        }[];
+    }>>;
+    function: z.ZodOptional<z.ZodObject<{
+        parameters: z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+            properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                items: z.ZodOptional<z.ZodAny>;
+                properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>>;
+            required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        }, {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        }>;
+        server: z.ZodObject<{
+            url: z.ZodString;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            url: string;
+            headers?: Record<string, string> | undefined;
+        }, {
+            url: string;
+            headers?: Record<string, string> | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        parameters: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        };
+        server: {
+            url: string;
+            headers?: Record<string, string> | undefined;
+        };
+    }, {
+        parameters: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        };
+        server: {
+            url: string;
+            headers?: Record<string, string> | undefined;
+        };
+    }>>;
+    apiRequest: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        method: z.ZodDefault<z.ZodEnum<["GET", "POST"]>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        body: z.ZodOptional<z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+            properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                items: z.ZodOptional<z.ZodAny>;
+                properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>>;
+            required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        }, {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        }>>;
+        backoffPlan: z.ZodOptional<z.ZodObject<{
+            type: z.ZodDefault<z.ZodEnum<["fixed", "exponential"]>>;
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            baseDelaySeconds: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            type: "fixed" | "exponential";
+            maxRetries: number;
+            baseDelaySeconds: number;
+        }, {
+            type?: "fixed" | "exponential" | undefined;
+            maxRetries?: number | undefined;
+            baseDelaySeconds?: number | undefined;
+        }>>;
+        timeoutSeconds: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        method: "GET" | "POST";
+        timeoutSeconds: number;
+        headers?: Record<string, string> | undefined;
+        body?: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        } | undefined;
+        backoffPlan?: {
+            type: "fixed" | "exponential";
+            maxRetries: number;
+            baseDelaySeconds: number;
+        } | undefined;
+    }, {
+        url: string;
+        headers?: Record<string, string> | undefined;
+        method?: "GET" | "POST" | undefined;
+        body?: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        } | undefined;
+        backoffPlan?: {
+            type?: "fixed" | "exponential" | undefined;
+            maxRetries?: number | undefined;
+            baseDelaySeconds?: number | undefined;
+        } | undefined;
+        timeoutSeconds?: number | undefined;
+    }>>;
+}, {
+    type: z.ZodEnum<["sms", "transferCall", "function", "apiRequest"]>;
+}>, "strip", z.ZodTypeAny, {
+    type: "function" | "sms" | "transferCall" | "apiRequest";
+    function?: {
+        parameters: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        };
+        server: {
+            url: string;
+            headers?: Record<string, string> | undefined;
+        };
+    } | undefined;
+    name?: string | undefined;
+    sms?: {
+        metadata: {
+            from: string;
+        };
+    } | undefined;
+    description?: string | undefined;
+    transferCall?: {
+        destinations: {
+            number: string;
+            type: "number";
+            extension?: string | undefined;
+            callerId?: string | undefined;
+            description?: string | undefined;
+        }[];
+    } | undefined;
+    apiRequest?: {
+        url: string;
+        method: "GET" | "POST";
+        timeoutSeconds: number;
+        headers?: Record<string, string> | undefined;
+        body?: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        } | undefined;
+        backoffPlan?: {
+            type: "fixed" | "exponential";
+            maxRetries: number;
+            baseDelaySeconds: number;
+        } | undefined;
+    } | undefined;
+}, {
+    type: "function" | "sms" | "transferCall" | "apiRequest";
+    function?: {
+        parameters: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        };
+        server: {
+            url: string;
+            headers?: Record<string, string> | undefined;
+        };
+    } | undefined;
+    name?: string | undefined;
+    sms?: {
+        metadata: {
+            from: string;
+        };
+    } | undefined;
+    description?: string | undefined;
+    transferCall?: {
+        destinations: {
+            number: string;
+            type: "number";
+            extension?: string | undefined;
+            callerId?: string | undefined;
+            description?: string | undefined;
+        }[];
+    } | undefined;
+    apiRequest?: {
+        url: string;
+        headers?: Record<string, string> | undefined;
+        method?: "GET" | "POST" | undefined;
+        body?: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        } | undefined;
+        backoffPlan?: {
+            type?: "fixed" | "exponential" | undefined;
+            maxRetries?: number | undefined;
+            baseDelaySeconds?: number | undefined;
+        } | undefined;
+        timeoutSeconds?: number | undefined;
+    } | undefined;
+}>;
+export declare const UpdateToolInputSchema: z.ZodObject<z.objectUtil.extendShape<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    sms: z.ZodOptional<z.ZodObject<{
+        metadata: z.ZodObject<{
+            from: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+        }, {
+            from: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        metadata: {
+            from: string;
+        };
+    }, {
+        metadata: {
+            from: string;
+        };
+    }>>;
+    transferCall: z.ZodOptional<z.ZodObject<{
+        destinations: z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"number">;
+            number: z.ZodString;
+            extension: z.ZodOptional<z.ZodString>;
+            callerId: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            number: string;
+            type: "number";
+            extension?: string | undefined;
+            callerId?: string | undefined;
+            description?: string | undefined;
+        }, {
+            number: string;
+            type: "number";
+            extension?: string | undefined;
+            callerId?: string | undefined;
+            description?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        destinations: {
+            number: string;
+            type: "number";
+            extension?: string | undefined;
+            callerId?: string | undefined;
+            description?: string | undefined;
+        }[];
+    }, {
+        destinations: {
+            number: string;
+            type: "number";
+            extension?: string | undefined;
+            callerId?: string | undefined;
+            description?: string | undefined;
+        }[];
+    }>>;
+    function: z.ZodOptional<z.ZodObject<{
+        parameters: z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+            properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                items: z.ZodOptional<z.ZodAny>;
+                properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>>;
+            required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        }, {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        }>;
+        server: z.ZodObject<{
+            url: z.ZodString;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            url: string;
+            headers?: Record<string, string> | undefined;
+        }, {
+            url: string;
+            headers?: Record<string, string> | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        parameters: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        };
+        server: {
+            url: string;
+            headers?: Record<string, string> | undefined;
+        };
+    }, {
+        parameters: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        };
+        server: {
+            url: string;
+            headers?: Record<string, string> | undefined;
+        };
+    }>>;
+    apiRequest: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        method: z.ZodDefault<z.ZodEnum<["GET", "POST"]>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        body: z.ZodOptional<z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+            properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                items: z.ZodOptional<z.ZodAny>;
+                properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>>;
+            required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        }, {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        }>>;
+        backoffPlan: z.ZodOptional<z.ZodObject<{
+            type: z.ZodDefault<z.ZodEnum<["fixed", "exponential"]>>;
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            baseDelaySeconds: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            type: "fixed" | "exponential";
+            maxRetries: number;
+            baseDelaySeconds: number;
+        }, {
+            type?: "fixed" | "exponential" | undefined;
+            maxRetries?: number | undefined;
+            baseDelaySeconds?: number | undefined;
+        }>>;
+        timeoutSeconds: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        method: "GET" | "POST";
+        timeoutSeconds: number;
+        headers?: Record<string, string> | undefined;
+        body?: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        } | undefined;
+        backoffPlan?: {
+            type: "fixed" | "exponential";
+            maxRetries: number;
+            baseDelaySeconds: number;
+        } | undefined;
+    }, {
+        url: string;
+        headers?: Record<string, string> | undefined;
+        method?: "GET" | "POST" | undefined;
+        body?: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        } | undefined;
+        backoffPlan?: {
+            type?: "fixed" | "exponential" | undefined;
+            maxRetries?: number | undefined;
+            baseDelaySeconds?: number | undefined;
+        } | undefined;
+        timeoutSeconds?: number | undefined;
+    }>>;
+}, {
+    toolId: z.ZodString;
+}>, "strip", z.ZodTypeAny, {
+    toolId: string;
+    function?: {
+        parameters: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        };
+        server: {
+            url: string;
+            headers?: Record<string, string> | undefined;
+        };
+    } | undefined;
+    name?: string | undefined;
+    sms?: {
+        metadata: {
+            from: string;
+        };
+    } | undefined;
+    description?: string | undefined;
+    transferCall?: {
+        destinations: {
+            number: string;
+            type: "number";
+            extension?: string | undefined;
+            callerId?: string | undefined;
+            description?: string | undefined;
+        }[];
+    } | undefined;
+    apiRequest?: {
+        url: string;
+        method: "GET" | "POST";
+        timeoutSeconds: number;
+        headers?: Record<string, string> | undefined;
+        body?: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        } | undefined;
+        backoffPlan?: {
+            type: "fixed" | "exponential";
+            maxRetries: number;
+            baseDelaySeconds: number;
+        } | undefined;
+    } | undefined;
+}, {
+    toolId: string;
+    function?: {
+        parameters: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        };
+        server: {
+            url: string;
+            headers?: Record<string, string> | undefined;
+        };
+    } | undefined;
+    name?: string | undefined;
+    sms?: {
+        metadata: {
+            from: string;
+        };
+    } | undefined;
+    description?: string | undefined;
+    transferCall?: {
+        destinations: {
+            number: string;
+            type: "number";
+            extension?: string | undefined;
+            callerId?: string | undefined;
+            description?: string | undefined;
+        }[];
+    } | undefined;
+    apiRequest?: {
+        url: string;
+        headers?: Record<string, string> | undefined;
+        method?: "GET" | "POST" | undefined;
+        body?: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                description?: string | undefined;
+                enum?: string[] | undefined;
+                items?: any;
+                properties?: Record<string, any> | undefined;
+                required?: string[] | undefined;
+            }>;
+            required?: string[] | undefined;
+        } | undefined;
+        backoffPlan?: {
+            type?: "fixed" | "exponential" | undefined;
+            maxRetries?: number | undefined;
+            baseDelaySeconds?: number | undefined;
+        } | undefined;
+        timeoutSeconds?: number | undefined;
+    } | undefined;
+}>;
 export declare const ToolOutputSchema: z.ZodObject<z.objectUtil.extendShape<{
     id: z.ZodString;
     createdAt: z.ZodString;
@@ -505,6 +1284,17 @@ export declare const ToolOutputSchema: z.ZodObject<z.objectUtil.extendShape<{
     type: z.ZodString;
     name: z.ZodString;
     description: z.ZodString;
+    parameters: z.ZodRecord<z.ZodString, z.ZodAny>;
+    server: z.ZodObject<{
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    }, {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    }>;
 }>, "strip", z.ZodTypeAny, {
     type: string;
     id: string;
@@ -512,6 +1302,11 @@ export declare const ToolOutputSchema: z.ZodObject<z.objectUtil.extendShape<{
     updatedAt: string;
     name: string;
     description: string;
+    parameters: Record<string, any>;
+    server: {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    };
 }, {
     type: string;
     id: string;
@@ -519,6 +1314,11 @@ export declare const ToolOutputSchema: z.ZodObject<z.objectUtil.extendShape<{
     updatedAt: string;
     name: string;
     description: string;
+    parameters: Record<string, any>;
+    server: {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    };
 }>;
 export {};
 //# sourceMappingURL=index.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;EAqB1B,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

@@ -233,7 +233,7 @@ export const CallInputSchema = z.object({
         .describe('ID of the phone number to use for the call'),
     customer: z
         .object({
-        phoneNumber: z.string().describe('Customer phone number'),
+        number: z.string().describe('Customer phone number'),
     })
         .optional()
         .describe('Customer information'),
@@ -241,6 +241,15 @@ export const CallInputSchema = z.object({
         .string()
         .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())
+            .optional()
+            .describe('Key-value pairs for dynamic variables to use in the assistant\'s prompts (e.g. {"name": "Joe", "age": "24"})'),
+    })
+        .optional()
+        .describe('Overrides for the assistant configuration'),
 });
 export const CallOutputSchema = BaseResponseSchema.extend({
     status: z.string(),
@@ -249,7 +258,7 @@ export const CallOutputSchema = BaseResponseSchema.extend({
     phoneNumberId: z.string().optional(),
     customer: z
         .object({
-        phoneNumber: z.string(),
+        number: z.string(),
     })
         .optional(),
     scheduledAt: z.string().optional(),
@@ -276,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/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,SA2CvB,CAAC"}

package/dist/tools/tool.js

@@ -1,5 +1,5 @@
-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 () => {
@@ -10,4 +10,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,CAmBpB;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

@@ -141,7 +141,7 @@ export function transformCallInput(input) {
         ...(input.customer
             ? {
                 customer: {
-                    number: input.customer.phoneNumber,
+                    number: input.customer.number,
                 },
             }
             : {}),
@@ -152,6 +152,11 @@ export function transformCallInput(input) {
                 },
             }
             : {}),
+        ...(input.assistantOverrides
+            ? {
+                assistantOverrides: input.assistantOverrides,
+            }
+            : {}),
     };
 }
 export function transformCallOutput(call) {
@@ -165,7 +170,7 @@ export function transformCallOutput(call) {
         phoneNumberId: call.phoneNumberId,
         customer: call.customer
             ? {
-                phoneNumber: call.customer.number || '',
+                number: call.customer.number || '',
             }
             : undefined,
         scheduledAt: call.schedulePlan?.earliestAt,
@@ -183,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,
@@ -191,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.7",
+  "version": "0.0.9",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -39,6 +39,7 @@
     "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",