@vapi-network/mcp 0.8.0 → 0.9.2

package/dist/server.d.ts

@@ -5,12 +5,13 @@ import { callService, type CallToolInput, type CallToolResult } from "./tools/ca
 import { type AccountsToolOverrides } from "./tools/accounts.js";
 import { type AuthAgentLinkOverrides } from "./tools/auth.js";
 import { type RouterCoreOverrides } from "./tools/router.js";
+import { type TasksOverrides } from "./tools/tasks.js";
 import { type StatusCoreOverrides } from "./tools/status.js";
 export { callService, type CallToolInput, type CallToolResult };
 export type VapiServerOptions = {
     /** The account opened before stdio was connected. */
-    account: VapiPaymentAccount;
-    config: VapiConfig;
+    account?: VapiPaymentAccount;
+    config?: VapiConfig;
     fetchImpl?: typeof fetch;
     ledgerPath?: string;
     receiptsPath?: string;
@@ -29,6 +30,8 @@ export type VapiServerOptions = {
     agentLink?: AuthAgentLinkOverrides | undefined;
     /** Core Router functions overridden by deterministic tests. */
     router?: RouterCoreOverrides | undefined;
+    /** Task transport, chain adapter and clocks overridden by deterministic tests. */
+    tasks?: TasksOverrides | undefined;
     /** Status probes and clock overridden by deterministic tests. */
     status?: StatusCoreOverrides | undefined;
     /** Account-link functions, device identity and clock overridden by deterministic tests. */
@@ -59,7 +62,6 @@ type ListedTool = {
     inputSchema: unknown;
     outputSchema?: unknown;
 };
-/** Minimal MCP server implementation for stdio and deterministic in-memory tests. */
 export declare class VapiMcpServer {
     #private;
     constructor(onClose?: () => void);
@@ -74,7 +76,7 @@ export declare class VapiMcpServer {
     connectStdio(): void;
     close(): Promise<void>;
 }
-export declare function createVapiServer(options: VapiServerOptions): VapiMcpServer;
+export declare function createVapiServer(options?: VapiServerOptions): VapiMcpServer;
 export declare function startStdioServer(options: VapiServerOptions): Promise<VapiMcpServer>;
 export declare function loadServerConfig(): Promise<{
     discoveryUrl: string;
@@ -98,5 +100,10 @@ export declare function loadServerConfig(): Promise<{
         marketplaceDiscoveryUrl: string;
     }[] | undefined;
     allowPrivateNetwork?: boolean | undefined;
+    tasksEscrowDurationOverrides?: Record<string, {
+        workDurationSeconds?: number | undefined;
+        reviewWindowSeconds?: number | undefined;
+    }> | undefined;
+    tasksEscrowFactoryOverrides?: Record<string, string> | undefined;
     device?: string | undefined;
 }>;

package/dist/tools/call.d.ts

@@ -31,16 +31,26 @@ export type ConfirmedSettlement = {
     receipt: unknown;
 };
 export declare class VapiCallError extends Error {
-    readonly code: "invalid_request" | "payment_rejected" | "receipt_write_failed" | "response_unreadable" | "settlement_unknown";
+    readonly code: "invalid_request" | "unsupported_network" | "payment_rejected" | "receipt_write_failed" | "response_unreadable" | "settlement_unknown";
     readonly possibleSettlement?: PossibleSettlement | undefined;
     readonly name = "VapiCallError";
     readonly paymentRejection?: PaymentRejection;
     readonly confirmedSettlement?: ConfirmedSettlement;
-    constructor(code: "invalid_request" | "payment_rejected" | "receipt_write_failed" | "response_unreadable" | "settlement_unknown", message: string, possibleSettlement?: PossibleSettlement | undefined, options?: ErrorOptions & {
+    constructor(code: "invalid_request" | "unsupported_network" | "payment_rejected" | "receipt_write_failed" | "response_unreadable" | "settlement_unknown", message: string, possibleSettlement?: PossibleSettlement | undefined, options?: ErrorOptions & {
         paymentRejection?: PaymentRejection;
         confirmedSettlement?: ConfirmedSettlement;
     });
 }
+/**
+ * The Solana network a listing pays on: its endpoint's payment network, or —
+ * when the endpoint carries none, as for mirrored rows resolved through the
+ * services API — the service's declared networks when every one is Solana.
+ */
+export declare function listingPaymentNetwork(endpointNetwork: string | undefined, serviceNetworks: readonly string[] | undefined): string | undefined;
+/** Refuse listing payments before any request, reservation, or signing. */
+export declare function assertSupportedListingNetwork(network: string | undefined): void;
+/** A selector cannot make a service payable when all its endpoints use Solana. */
+export declare function assertSupportedListingResolution(error: unknown): void;
 export type CallToolResult = {
     status: number;
     body: unknown;

package/dist/tools/docs.d.ts

@@ -0,0 +1,36 @@
+import { type DocsReadResponse, type DocsSearchResponse } from "@vapi-network/core";
+import { z } from "zod";
+export declare const docsSearchTool: {
+    description: string;
+    inputSchema: {
+        query: z.ZodString;
+    };
+    outputSchema: z.ZodObject<{
+        results: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            url: z.ZodString;
+            excerpt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+};
+export declare const docsReadTool: {
+    description: string;
+    inputSchema: {
+        url: z.ZodString;
+    };
+    outputSchema: z.ZodObject<{
+        url: z.ZodString;
+        markdown: z.ZodString;
+    }, z.core.$strip>;
+};
+export declare function createDocsTools(options: {
+    fetchImpl?: typeof fetch;
+    env?: NodeJS.ProcessEnv;
+}): {
+    search(input: {
+        query: string;
+    }): Promise<DocsSearchResponse>;
+    read(input: {
+        url: string;
+    }): Promise<DocsReadResponse>;
+};

package/dist/tools/tasks.d.ts

@@ -0,0 +1,383 @@
+import { type SecretStore, type WalletStore } from "@vapi-network/core";
+import { type TasksChain, type TasksClient, type TasksClientOptions } from "@vapi-network/core/tasks";
+import { z } from "zod";
+import type { WalletSession } from "../wallet-session.js";
+export declare const tasksSearchTool: {
+    description: string;
+    inputSchema: {
+        open: z.ZodOptional<z.ZodBoolean>;
+        minUsd: z.ZodOptional<z.ZodString>;
+        tab: z.ZodOptional<z.ZodEnum<{
+            paid: "paid";
+            trending: "trending";
+            new: "new";
+            closing: "closing";
+        }>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    };
+    strictInput: true;
+};
+export declare const tasksShowTool: {
+    description: string;
+    inputSchema: {
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksPostTool: {
+    description: string;
+    inputSchema: {
+        title: z.ZodString;
+        brief: z.ZodString;
+        amountUsd: z.ZodString;
+        deadline: z.ZodString;
+        intake: z.ZodOptional<z.ZodEnum<{
+            proposals: "proposals";
+            submissions: "submissions";
+        }>>;
+        maxAwards: z.ZodOptional<z.ZodNumber>;
+        webhookUrl: z.ZodOptional<z.ZodURL>;
+        vendor: z.ZodOptional<z.ZodString>;
+        wallet: z.ZodOptional<z.ZodString>;
+    };
+    strictInput: true;
+};
+export declare const tasksProposeTool: {
+    description: string;
+    inputSchema: {
+        priceUsd: z.ZodString;
+        duration: z.ZodString;
+        note: z.ZodString;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksSubmitTool: {
+    description: string;
+    inputSchema: {
+        proofUrls: z.ZodArray<z.ZodURL>;
+        files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksAwardTool: {
+    description: string;
+    inputSchema: {
+        proposalId: z.ZodUUID;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksSignTool: {
+    description: string;
+    inputSchema: {
+        wait: z.ZodDefault<z.ZodBoolean>;
+        counterparty: z.ZodOptional<z.ZodString>;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksFundTool: {
+    description: string;
+    inputSchema: {
+        wait: z.ZodDefault<z.ZodBoolean>;
+        counterparty: z.ZodOptional<z.ZodString>;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksDeliverTool: {
+    description: string;
+    inputSchema: {
+        wait: z.ZodDefault<z.ZodBoolean>;
+        files: z.ZodArray<z.ZodString>;
+        note: z.ZodString;
+        counterparty: z.ZodOptional<z.ZodString>;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksReleaseTool: {
+    description: string;
+    inputSchema: {
+        wait: z.ZodDefault<z.ZodBoolean>;
+        counterparty: z.ZodOptional<z.ZodString>;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksRefundTool: {
+    description: string;
+    inputSchema: {
+        counterparty: z.ZodOptional<z.ZodString>;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksDisputeTool: {
+    description: string;
+    inputSchema: {
+        evidenceHash: z.ZodString;
+        counterparty: z.ZodOptional<z.ZodString>;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksCounterEvidenceTool: {
+    description: string;
+    inputSchema: {
+        evidenceHash: z.ZodString;
+        counterparty: z.ZodOptional<z.ZodString>;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksResolveUnmatchedTool: {
+    description: string;
+    inputSchema: {
+        counterparty: z.ZodOptional<z.ZodString>;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksMessageTool: {
+    description: string;
+    inputSchema: {
+        text: z.ZodString;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksThreadTool: {
+    description: string;
+    inputSchema: {
+        after: z.ZodOptional<z.ZodNumber>;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksWatchTool: {
+    description: string;
+    inputSchema: {
+        after: z.ZodDefault<z.ZodNumber>;
+        until: z.ZodOptional<z.ZodEnum<{
+            paid: "paid";
+            cancelled: "cancelled";
+            open: "open";
+            awarded: "awarded";
+            funded: "funded";
+            delivered: "delivered";
+            released: "released";
+            refunded: "refunded";
+            disputed: "disputed";
+            expired: "expired";
+            closed: "closed";
+            completed: "completed";
+        }>>;
+        waitSeconds: z.ZodDefault<z.ZodNumber>;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksStatusTool: {
+    description: string;
+    inputSchema: {
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export type TasksOverrides = {
+    client?: TasksClient | ((options: TasksClientOptions) => TasksClient);
+    chain?: TasksChain;
+    randomUUID?: () => string;
+    now?: () => Date;
+    sleep?: (ms: number) => Promise<void>;
+};
+type TasksToolsOptions = TasksOverrides & {
+    session: WalletSession;
+    secrets: SecretStore;
+    wallets?: WalletStore | undefined;
+    fetchImpl: typeof fetch;
+    apiBase: string;
+    ledgerPath?: string | undefined;
+};
+type Input<T extends {
+    inputSchema: z.ZodRawShape;
+}> = z.infer<z.ZodObject<T["inputSchema"]>>;
+export declare function createTasksTools(options: TasksToolsOptions): {
+    search(input: Input<typeof tasksSearchTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    show(input: Input<typeof tasksShowTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    post(input: Input<typeof tasksPostTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    propose(input: Input<typeof tasksProposeTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    submit(input: Input<typeof tasksSubmitTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    award(input: Input<typeof tasksAwardTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    sign(input: Input<typeof tasksSignTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    } | {
+        isError: true;
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    fund(input: Input<typeof tasksFundTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    deliver(input: Input<typeof tasksDeliverTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    release(input: Input<typeof tasksReleaseTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    refund(input: Input<typeof tasksRefundTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    dispute(input: Input<typeof tasksDisputeTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    counterEvidence(input: Input<typeof tasksCounterEvidenceTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    resolveUnmatched(input: Input<typeof tasksResolveUnmatchedTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    message(input: Input<typeof tasksMessageTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    thread(input: Input<typeof tasksThreadTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    watch(input: Input<typeof tasksWatchTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+    status(input: Input<typeof tasksStatusTool>): Promise<{
+        structuredContent: {};
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true | undefined;
+    }>;
+};
+export declare function tasksErrorResult(error: unknown, extra?: Record<string, unknown>): {
+    isError: true;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vapi-network/mcp",
-  "version": "0.8.0",
+  "version": "0.9.2",
   "description": "Local, non-custodial MCP server for discovering and paying x402 APIs",
   "license": "Apache-2.0",
   "repository": {