@vapi-ai/mcp-server 0.0.11 → 0.2.0

package/dist/knowledge/skills.js

@@ -0,0 +1,131 @@
+import { parse } from 'yaml';
+import { z } from 'zod';
+const REPOSITORY = 'https://github.com/VapiAI/skills';
+const API = 'https://api.github.com/repos/VapiAI/skills';
+const RAW = 'https://raw.githubusercontent.com/VapiAI/skills';
+const CACHE_MS = 5 * 60_000;
+const TEXT_FILE = /\.(md|txt|json|ya?ml|py|[cm]?js|ts|sh|rst|toml)$/i;
+const commitSchema = z.object({ sha: z.string().regex(/^[a-f0-9]{40}$/) });
+const treeSchema = z.object({
+    truncated: z.literal(false),
+    tree: z.array(z.object({ path: z.string(), type: z.string(), mode: z.string() })),
+});
+// Each MCP server has its own bounded-lifetime snapshot. Rejected fetches are
+// evicted so an upstream outage doesn't poison later calls.
+export class PublicSkills {
+    fetcher;
+    cached;
+    constructor(fetcher = fetch) {
+        this.fetcher = fetcher;
+    }
+    async read(url, maxBytes = 512_000) {
+        const response = await this.fetcher(url, {
+            signal: AbortSignal.timeout(15_000),
+            redirect: 'error',
+            headers: { Accept: 'application/vnd.github+json', 'User-Agent': 'vapi-mcp-server' },
+        });
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new Error(`Public skills request failed (HTTP ${response.status}). Retry later.`);
+        }
+        if (!response.body)
+            throw new Error('Public skills returned an empty response.');
+        const reader = response.body.getReader();
+        const chunks = [];
+        let size = 0;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.byteLength;
+                if (size > maxBytes)
+                    throw new Error('Public skills response exceeds the supported size.');
+                chunks.push(value);
+            }
+        }
+        finally {
+            await reader.cancel().catch(() => undefined);
+            reader.releaseLock();
+        }
+        return Buffer.concat(chunks).toString('utf8');
+    }
+    snapshot() {
+        if (this.cached && this.cached.expiresAt > Date.now())
+            return this.cached.promise;
+        const promise = (async () => {
+            // Pin file reads to one commit so SKILL.md and its references agree even
+            // when the public repository changes between requests.
+            const { sha } = commitSchema.parse(JSON.parse(await this.read(`${API}/commits/main`)));
+            const tree = treeSchema.parse(JSON.parse(await this.read(`${API}/git/trees/${sha}?recursive=1`, 2_000_000)));
+            const files = new Set(tree.tree.filter(entry => entry.type === 'blob' && ['100644', '100755'].includes(entry.mode)).map(entry => entry.path));
+            const names = [...files].filter(path => /^[a-z0-9]+(?:-[a-z0-9]+)*\/SKILL\.md$/.test(path)).map(path => path.split('/')[0]).sort();
+            if (!names.length)
+                throw new Error('No public Vapi skills were found. Retry later.');
+            return { revision: sha, files, names, contents: new Map() };
+        })();
+        this.cached = { expiresAt: Date.now() + CACHE_MS, promise };
+        void promise.catch(() => { if (this.cached?.promise === promise)
+            this.cached = undefined; });
+        return promise;
+    }
+    content(snapshot, path) {
+        const cached = snapshot.contents.get(path);
+        if (cached)
+            return cached;
+        const encodedPath = path.split('/').map(encodeURIComponent).join('/');
+        const promise = this.read(`${RAW}/${snapshot.revision}/${encodedPath}`);
+        if (snapshot.contents.size >= 100)
+            snapshot.contents.delete(snapshot.contents.keys().next().value);
+        snapshot.contents.set(path, promise);
+        void promise.catch(() => snapshot.contents.delete(path));
+        return promise;
+    }
+    async skill(snapshot, name) {
+        const content = await this.content(snapshot, `${name}/SKILL.md`);
+        const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(content);
+        if (!frontmatter)
+            throw new Error(`Invalid frontmatter for public skill ${name}.`);
+        const metadata = z.object({ name: z.literal(name), description: z.string().min(1) }).parse(parse(frontmatter[1]));
+        return { name, description: metadata.description, content };
+    }
+    async search(query, limit) {
+        const snapshot = await this.snapshot();
+        const skills = [];
+        // Limit concurrent public requests when warming a new snapshot.
+        for (let index = 0; index < snapshot.names.length; index += 4) {
+            skills.push(...await Promise.all(snapshot.names.slice(index, index + 4).map(name => this.skill(snapshot, name))));
+        }
+        const terms = [...new Set(query.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [])];
+        const matches = skills.map(skill => ({
+            skill,
+            score: terms.reduce((score, term) => score +
+                (skill.name.includes(term) ? 5 : 0) +
+                (skill.description.toLowerCase().includes(term) ? 3 : 0) +
+                (skill.content.toLowerCase().includes(term) ? 1 : 0), 0),
+        })).filter(({ score }) => !terms.length || score > 0)
+            .sort((a, b) => b.score - a.score || a.skill.name.localeCompare(b.skill.name));
+        return {
+            repository: REPOSITORY, revision: snapshot.revision, total: matches.length,
+            skills: matches.slice(0, limit).map(({ skill }) => ({
+                name: skill.name, description: skill.description,
+                sourceUrl: `${REPOSITORY}/blob/${snapshot.revision}/${skill.name}/SKILL.md`,
+            })),
+        };
+    }
+    async load(name, path) {
+        const snapshot = await this.snapshot();
+        if (!snapshot.names.includes(name))
+            throw new Error(`Unknown public skill. Use search_skills to find a skill name.`);
+        const files = [...snapshot.files].filter(file => file.startsWith(`${name}/`) && TEXT_FILE.test(file)).map(file => file.slice(name.length + 1)).sort();
+        // Exact tree membership, not URL/path normalization, bounds reads to this
+        // skill and excludes traversal, URLs, symlinks and binary assets.
+        if (!files.includes(path))
+            throw new Error('Unknown skill file. Load SKILL.md to see the available files.');
+        return {
+            name, path, revision: snapshot.revision,
+            sourceUrl: `${REPOSITORY}/blob/${snapshot.revision}/${name}/${path}`,
+            content: await this.content(snapshot, `${name}/${path}`), files,
+        };
+    }
+}

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

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+type JsonSchema = z.core.JSONSchema.JSONSchema;
+export declare const requiredToolConfigurations: string[];
+export declare const functionRequiresName: boolean;
+export declare function inputContract(value: unknown, schemaMap?: boolean): unknown;
+export declare function providerContract(field: 'voice' | 'transcriber' | 'llm'): JsonSchema;
+export declare const providersRequiringExpandedInputs: {
+    [k: string]: string[];
+};
+type VoiceConfiguration = {
+    provider: string;
+    voiceId: string;
+    model?: string;
+};
+type TranscriberConfiguration = {
+    provider: string;
+    model?: string;
+};
+export declare const VoiceInputSchema: z.ZodType<VoiceConfiguration>;
+export declare const TranscriberInputSchema: z.ZodType<TranscriberConfiguration>;
+export declare const CreateAssistantNameSchema: z.ZodType<string>;
+export declare const UpdateAssistantNameSchema: z.ZodType<string>;
+export declare const LLMInputSchema: z.ZodType<{
+    provider: string;
+    model?: string;
+}>;
+export declare function fieldContract(name: string): JsonSchema;
+export declare function apiField<T = unknown>(name: string, overrides?: Partial<JsonSchema>): z.ZodType<T>;
+export declare function apiObjectField<T = Record<string, unknown>>(name: string): z.ZodType<T>;
+export {};
+//# sourceMappingURL=assistant-openapi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assistant-openapi.d.ts","sourceRoot":"","sources":["../../src/schemas/assistant-openapi.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,KAAK,UAAU,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;AAkB/C,eAAO,MAAM,0BAA0B,UAAsC,CAAC;AAC9E,eAAO,MAAM,oBAAoB,SAAgC,CAAC;AAKlE,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,UAAQ,GAAG,OAAO,CAiCxE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,GAAG,KAAK,GAAG,UAAU,CAanF;AAID,eAAO,MAAM,gCAAgC;;CAI5C,CAAC;AAEF,KAAK,kBAAkB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAChF,KAAK,wBAAwB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAIrE,eAAO,MAAM,gBAAgB,EAAoF,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAC/I,eAAO,MAAM,sBAAsB,EAA0F,CAAC,CAAC,OAAO,CAAC,wBAAwB,CAAC,CAAC;AACjK,eAAO,MAAM,yBAAyB,EAA+E,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;AACvI,eAAO,MAAM,yBAAyB,EAA+E,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;AAEvI,eAAO,MAAM,cAAc,EAAkF,CAAC,CAAC,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAE7J,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAKtD;AAED,wBAAgB,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,OAAO,CAAC,UAAU,CAAM,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAErG;AAED,wBAAgB,cAAc,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAKtF"}

package/dist/schemas/assistant-openapi.js

@@ -0,0 +1,87 @@
+import { readFileSync } from 'node:fs';
+import { z } from 'zod';
+const snapshot = JSON.parse(readFileSync(new URL('./assistant-openapi.json', import.meta.url), 'utf8'));
+export const requiredToolConfigurations = snapshot.requiredToolConfigurations;
+export const functionRequiresName = snapshot.functionRequiresName;
+// The published spec uses overlapping oneOf [enum, string] branches for preset
+// IDs and model names. The API accepts both. Change only this recognizable
+// pattern, leaving discriminated/exclusive unions intact.
+export function inputContract(value, schemaMap = false) {
+    if (Array.isArray(value))
+        return value.map(item => inputContract(item));
+    if (!value || typeof value !== 'object')
+        return value;
+    const schema = value;
+    // Property names such as oneOf/default are user-defined keys in schema maps,
+    // rather than JSON Schema keywords. Preserve them and normalize their values.
+    if (schemaMap)
+        return Object.fromEntries(Object.entries(schema).map(([key, nested]) => [key, inputContract(nested)]));
+    // An empty published preset enum denotes no preset values. Represent that
+    // branch as an always-failing schema so it remains valid JSON Schema.
+    if (Array.isArray(schema.enum) && schema.enum.length === 0)
+        return { not: {} };
+    const alternatives = Array.isArray(schema.oneOf) ? schema.oneOf : undefined;
+    const overlap = alternatives?.some(branch => branch.type === 'string' &&
+        Object.keys(branch).every(key => ['type', 'title', 'description'].includes(key))) &&
+        alternatives.some(branch => branch.type === 'string' && Array.isArray(branch.enum));
+    return Object.fromEntries(Object.entries(schema)
+        // OpenAPI defaults are annotations; preserve omitted input fields and let
+        // the API apply its defaults rather than materializing them in requests.
+        .filter(([key]) => key !== 'default')
+        .map(([key, nested]) => [
+        key === 'oneOf' && overlap ? 'anyOf' : key,
+        // Some published voice IDs repeat in enum arrays. Deduplication changes
+        // no accepted values and keeps the result valid JSON Schema for Ajv.
+        key === 'enum' && Array.isArray(nested) ? [...new Set(nested)]
+            // Published name patterns include JavaScript /.../ delimiters, while
+            // JSON Schema pattern expects the regex source without delimiters.
+            : key === 'pattern' && typeof nested === 'string' && nested.startsWith('/') && nested.endsWith('/') ? nested.slice(1, -1)
+                // BackoffPlan.type is published as object with a string enum. Keep the
+                // enum's actual value type; the incompatible type annotation is a spec defect.
+                : key === 'type' && nested === 'object' && Array.isArray(schema.enum) && schema.enum.every(v => typeof v === 'string') ? 'string'
+                    : ['properties', 'definitions', '$defs', 'patternProperties', 'dependentSchemas'].includes(key) ? inputContract(nested, true)
+                        : ['allOf', 'anyOf', 'oneOf', 'not', 'items', 'additionalProperties', 'contains', 'if', 'then', 'else'].includes(key) ? inputContract(nested)
+                            : nested,
+    ]));
+}
+export function providerContract(field) {
+    const supported = snapshot[field].filter(definition => definition.required.every(key => key in definition.properties));
+    return {
+        oneOf: supported.map(definition => ({
+            type: 'object',
+            required: definition.required,
+            properties: inputContract(definition.properties, true),
+            // API DTOs reject undeclared provider fields. In particular, a provider
+            // without a model property must reject model, not silently accept it.
+            additionalProperties: false,
+        })),
+    };
+}
+// Providers requiring fields outside the existing compact MCP surface stay
+// unsupported, rather than having those API-required fields silently dropped.
+export const providersRequiringExpandedInputs = Object.fromEntries(['voice', 'transcriber', 'llm'].map(field => [field, snapshot[field]
+        .filter(definition => definition.required.some(key => !(key in definition.properties)))
+        .map(definition => definition.name)]));
+// fromJSONSchema validates at runtime but intentionally returns an untyped
+// ZodType. These types describe the projected fields, not a second validator.
+export const VoiceInputSchema = z.fromJSONSchema(providerContract('voice'), { defaultTarget: 'openapi-3.0' });
+export const TranscriberInputSchema = z.fromJSONSchema(providerContract('transcriber'), { defaultTarget: 'openapi-3.0' });
+export const CreateAssistantNameSchema = z.fromJSONSchema(snapshot.name.create, { defaultTarget: 'openapi-3.0' });
+export const UpdateAssistantNameSchema = z.fromJSONSchema(snapshot.name.update, { defaultTarget: 'openapi-3.0' });
+export const LLMInputSchema = z.fromJSONSchema(providerContract('llm'), { defaultTarget: 'openapi-3.0' });
+export function fieldContract(name) {
+    const field = snapshot.fields[name];
+    if (!field)
+        throw new Error(`Unknown API input field: ${name}`);
+    return JSON.parse(JSON.stringify(inputContract({ ...field, definitions: snapshot.definitions }), (key, value) => key === '$ref' && typeof value === 'string' ? value.replace('#/components/schemas/', '#/definitions/') : value));
+}
+export function apiField(name, overrides = {}) {
+    return z.fromJSONSchema({ ...fieldContract(name), ...overrides }, { defaultTarget: 'openapi-3.0' });
+}
+export function apiObjectField(name) {
+    const schema = apiField(name);
+    if (!(schema instanceof z.ZodObject))
+        throw new Error(`${name} is no longer an object schema`);
+    // Preserve the existing MCP policy of stripping unknown envelope fields.
+    return schema.strip();
+}