npm - @vapi-ai/mcp-server - Versions diffs - 0.0.8 → 0.0.9 - Mend

@vapi-ai/mcp-server 0.0.8 → 0.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/schemas/index.d.ts +787 -0
package/dist/schemas/index.d.ts.map +1 -1
package/dist/schemas/index.js +69 -0
package/dist/tools/tool.d.ts.map +1 -1
package/dist/tools/tool.js +12 -2
package/dist/transformers/index.d.ts +4 -2
package/dist/transformers/index.d.ts.map +1 -1
package/dist/transformers/index.js +114 -0
package/package.json +1 -1

package/dist/schemas/index.d.ts CHANGED Viewed

@@ -510,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;
@@ -518,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;
@@ -525,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;
@@ -532,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 CHANGED Viewed

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

package/dist/schemas/index.js CHANGED Viewed

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

package/dist/tools/tool.d.ts.map CHANGED Viewed

	@@ -1 +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"}
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,SA2CvB,CAAC"}

package/dist/tools/tool.js CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

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

package/dist/transformers/index.js CHANGED Viewed

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

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "@vapi-ai/mcp-server",
   "description": "Vapi MCP Server",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",