@vapi-network/mcp 0.7.0 → 0.9.0

package/dist/server.d.ts

@@ -1,15 +1,17 @@
-import { type SecretStore, type VapiPaymentAccount, type VapiConfig, type WalletStore } from "@vapi-network/core";
+import { type SecretStore, type SwarmCapitalDeps, type VapiPaymentAccount, type VapiConfig, type WalletStore } from "@vapi-network/core";
 import { z } from "zod";
+import { type Runtime } from "./agent/runtime.js";
 import { callService, type CallToolInput, type CallToolResult } from "./tools/call.js";
 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;
@@ -28,10 +30,16 @@ 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. */
     accounts?: AccountsToolOverrides | undefined;
+    /** Swarm capital seams overridden by deterministic tests. */
+    swarm?: Pick<SwarmCapitalDeps, "balanceReader" | "transfer" | "randomId" | "randomNonce"> | undefined;
+    /** Background runtime used by detached swarm runs. */
+    runtime?: Runtime | undefined;
 };
 type ToolResult = {
     isError?: boolean;
@@ -69,7 +77,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;
@@ -93,5 +101,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/accounts.d.ts

@@ -1,6 +1,8 @@
 import { type AddAccountArgs, type SecretStore, type TransferArgs, type WalletStore } from "@vapi-network/core";
 import { z } from "zod";
+import type { AccountsPort } from "../actions/context.js";
 import type { WalletSession } from "../wallet-session.js";
+export { accountsSendInputSchema, accountsSendOutputSchema } from "../actions/accounts.js";
 export declare const accountsAddTool: {
     description: string;
     strictInput: boolean;
@@ -108,6 +110,7 @@ export type AccountsToolsOptions = AccountsToolOverrides & {
     env?: NodeJS.ProcessEnv | undefined;
     signal?: AbortSignal | undefined;
 };
+export type CreateAccountsPortOptions = Pick<AccountsToolsOptions, "session" | "secrets" | "wallets" | "fetchImpl" | "apiBase" | "now" | "nonce">;
 type ToolResult = {
     structuredContent: Record<string, unknown>;
     content: Array<{
@@ -138,11 +141,5 @@ export declare function createAccountsTools(options: AccountsToolsOptions): {
         perDayUsd?: number;
         ceilingUsd?: number | "off";
     }): Promise<ToolResult>;
-    send(input: {
-        from: string;
-        to: string;
-        amountUsd: string | number;
-        network?: "base" | "arc";
-    }): Promise<ToolResult>;
 };
-export {};
+export declare function createAccountsPort(options: CreateAccountsPortOptions): AccountsPort;

package/dist/tools/call.d.ts

@@ -1,4 +1,4 @@
-import { type ListingVerification, type LookupFn, type MarketplaceHit, type CeilingSweepHook, type SpendCaps, type VapiPaymentAccount, type VapiConfig, type WalletName } from "@vapi-network/core";
+import { type ListingVerification, type LookupFn, type MarketplaceHit, type RunBudget, type RunRef, type CeilingSweepHook, type SpendCaps, type VapiPaymentAccount, type VapiConfig, type WalletName } from "@vapi-network/core";
 export type CallToolInput = {
     id?: string;
     url?: string;
@@ -44,6 +44,8 @@ export declare class VapiCallError extends Error {
 export type CallToolResult = {
     status: number;
     body: unknown;
+    /** The final resource URL after guarded redirects, present when a payment settled. */
+    resourceUrl?: string;
     /**
      * How far the paid listing got through vAPI review. Absent when there was no
      * listing to disclose — a call made against an explicit URL.
@@ -78,8 +80,11 @@ export type CallServiceArgs = {
     /** The caps of that wallet. Without it, the machine-wide config caps apply. */
     spendCaps?: SpendCaps;
     now?: Date;
+    allowanceExpiresAt?: Date;
     nowMs?: () => number;
     timeoutMs?: number;
+    runBudget?: RunBudget;
+    run?: RunRef;
     /** Best-effort account ceiling enforcement after decisive settlement. */
     ceilingSweep?: CeilingSweepHook | false;
 };

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/status.d.ts

@@ -35,8 +35,8 @@ export declare const vapiStatusTool: {
             link: z.ZodEnum<{
                 unknown: "unknown";
                 paused: "paused";
-                active: "active";
                 not_linked: "not_linked";
+                active: "active";
                 revoked: "revoked";
             }>;
         }, z.core.$strip>>;
@@ -71,8 +71,8 @@ export declare const vapiAccountsTool: {
             link: z.ZodEnum<{
                 unknown: "unknown";
                 paused: "paused";
-                active: "active";
                 not_linked: "not_linked";
+                active: "active";
                 revoked: "revoked";
             }>;
         }, z.core.$strip>>;

package/dist/tools/tasks.d.ts

@@ -0,0 +1,377 @@
+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>;
+        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: {
+        counterparty: z.ZodOptional<z.ZodString>;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksFundTool: {
+    description: string;
+    inputSchema: {
+        counterparty: z.ZodOptional<z.ZodString>;
+        wallet: z.ZodOptional<z.ZodString>;
+        id: z.ZodUUID;
+    };
+    strictInput: true;
+};
+export declare const tasksDeliverTool: {
+    description: string;
+    inputSchema: {
+        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: {
+        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: {
+        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.7.0",
+  "version": "0.9.0",
   "description": "Local, non-custodial MCP server for discovering and paying x402 APIs",
   "license": "Apache-2.0",
   "repository": {