@vapi-network/mcp 0.1.1 → 0.2.0

package/dist/server.d.ts

@@ -0,0 +1,72 @@
+import { type VapiPaymentAccount, type VapiConfig } from "@vapi-network/core";
+import { z } from "zod";
+import { callService, type CallToolInput, type CallToolResult } from "./tools/call.js";
+export { callService, type CallToolInput, type CallToolResult };
+export type VapiServerOptions = {
+    account: VapiPaymentAccount;
+    config: VapiConfig;
+    fetchImpl?: typeof fetch;
+    ledgerPath?: string;
+    receiptsPath?: string;
+    searchesPath?: string;
+    reportsDirectory?: string;
+};
+type ToolResult = {
+    isError?: boolean;
+    structuredContent?: Record<string, unknown>;
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+};
+type ToolDefinition<Shape extends z.ZodRawShape> = {
+    description?: string;
+    deprecatedReplacement?: string;
+    inputSchema: Shape;
+    outputSchema?: z.ZodType;
+};
+type ListedTool = {
+    name: string;
+    description?: string;
+    inputSchema: unknown;
+    outputSchema?: unknown;
+};
+/** Minimal MCP server implementation for stdio and deterministic in-memory tests. */
+export declare class VapiMcpServer {
+    #private;
+    registerTool<Shape extends z.ZodRawShape>(name: string, definition: ToolDefinition<Shape>, handler: (input: z.infer<z.ZodObject<Shape>>) => Promise<ToolResult>): void;
+    listTools(): Promise<{
+        tools: ListedTool[];
+    }>;
+    callTool(request: {
+        name: string;
+        arguments?: Record<string, unknown>;
+    }): Promise<ToolResult>;
+    connectStdio(): void;
+    close(): Promise<void>;
+}
+export declare function createVapiServer(options: VapiServerOptions): VapiMcpServer;
+export declare function startStdioServer(options: VapiServerOptions): Promise<VapiMcpServer>;
+export declare function loadServerConfig(): Promise<{
+    discoveryUrl: string;
+    marketplaceDiscoveryUrl: string;
+    networks: Record<string, {
+        rpcUrl: string;
+        usdc: string;
+        depositUrl?: string | undefined;
+        depositInstructions?: string | undefined;
+        eip712Domain?: {
+            name: string;
+            version: string;
+        } | undefined;
+    }>;
+    spendCaps: {
+        perCallAtomic: string;
+        perDayAtomic: string;
+    };
+    registryFallbacks?: {
+        discoveryUrl: string;
+        marketplaceDiscoveryUrl: string;
+    }[] | undefined;
+    allowPrivateNetwork?: boolean | undefined;
+}>;

package/dist/siwx.d.ts

@@ -0,0 +1,12 @@
+import { type SIWxChallenge, type SIWxSigner, type VapiConfig } from "@vapi-network/core";
+export declare function parseSIWxResponse(response: Response, configuredNetworks: VapiConfig["networks"], responseUrl: string, requiredNetwork?: string): Promise<SIWxChallenge | null>;
+export declare function buildSIWxProof(args: {
+    signer: SIWxSigner;
+    challenge: SIWxChallenge;
+    responseUrl: string;
+}): Promise<{
+    payload: import("@vapi-network/core").SIWxPayload;
+    headers: Readonly<{
+        "SIGN-IN-WITH-X": string;
+    }>;
+}>;

package/dist/tools/call.d.ts

@@ -0,0 +1,74 @@
+import { type LookupFn, type MarketplaceHit, type VapiPaymentAccount, type VapiConfig } from "@vapi-network/core";
+export type CallToolInput = {
+    id?: string;
+    url?: string;
+    method?: string;
+    endpoint?: string;
+    body?: unknown;
+    maxPriceUsd?: number | string;
+    network?: string;
+    expectedPayTo?: string;
+    contentType?: string;
+};
+export type PossibleSettlement = {
+    network: string;
+    asset: string;
+    amountAtomic: string;
+    payTo: string;
+    payer: string;
+    authorizationNonce?: string;
+    authorizationExpiresAt?: string;
+    authorizationTransaction?: string;
+    receipt: unknown | null;
+};
+export type PaymentRejection = {
+    httpStatus: number;
+    receipt: unknown;
+};
+export type ConfirmedSettlement = {
+    httpStatus: number;
+    receipt: unknown;
+};
+export declare class VapiCallError extends Error {
+    readonly code: "invalid_request" | "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 & {
+        paymentRejection?: PaymentRejection;
+        confirmedSettlement?: ConfirmedSettlement;
+    });
+}
+export type CallToolResult = {
+    status: number;
+    body: unknown;
+    outcome?: "signed_in";
+    payment: null | {
+        network: string;
+        amountAtomic: string;
+        amountUsd: string;
+        asset: string;
+        payTo: string;
+        settlement: unknown | null;
+        proof: string | null;
+    };
+    expectedRequest?: {
+        contentType?: string;
+        schema?: unknown;
+    };
+};
+export type CallServiceArgs = {
+    input: CallToolInput;
+    marketplaceHit?: MarketplaceHit;
+    account: VapiPaymentAccount;
+    config: VapiConfig;
+    fetchImpl?: typeof fetch;
+    lookup?: LookupFn;
+    ledgerPath?: string;
+    receiptsPath?: string;
+    now?: Date;
+    nowMs?: () => number;
+    timeoutMs?: number;
+};
+export declare function callService(args: CallServiceArgs): Promise<CallToolResult>;

package/dist/tools/inspect.d.ts

@@ -0,0 +1,14 @@
+import { type DiscoveryEndpoint, type ListingFee, type ListingGroup, type VapiConfig } from "@vapi-network/core";
+export type InspectToolInput = {
+    id: string;
+    endpoint?: string;
+};
+export type InspectToolResult = Omit<Pick<DiscoveryEndpoint, "name" | "method" | "url" | "price" | "description" | "operationId" | "requestContentType" | "requestSchema" | "responseContentType">, "method"> & {
+    method: string | null;
+    network?: string;
+    /** Registry-owned listing disclosures; absent when the registry omits them. */
+    group?: ListingGroup;
+    fee?: ListingFee;
+    payment: DiscoveryEndpoint["payment"] | null;
+};
+export declare function inspectService(input: InspectToolInput, config: VapiConfig, fetchImpl?: typeof fetch): Promise<InspectToolResult>;

package/dist/tools/search.d.ts

@@ -0,0 +1 @@
+export { findMarketplaceApiByRef, resolveServiceEndpoint, resolveServiceListing, searchMarketplace, type MarketplaceSearchInput, } from "@vapi-network/sources";

package/dist/tools/wallet.d.ts

@@ -0,0 +1,16 @@
+import { type LookupFn, type VapiPaymentAccount, type VapiConfig } from "@vapi-network/core";
+import type { Address } from "viem";
+export type WalletBalance = {
+    network: string;
+    name: string;
+    usdcAtomic: string | null;
+    usdc: string | null;
+    error?: string;
+};
+export declare function getWallet(account: Address | VapiPaymentAccount, config: VapiConfig, options?: {
+    fetchImpl?: typeof fetch;
+    lookup?: LookupFn;
+}): Promise<{
+    address: Address;
+    balances: WalletBalance[];
+}>;

package/dist/x402.d.ts

@@ -0,0 +1,19 @@
+import { EIP3009_AUTHORIZATION_TYPES, X402Error, assertMaxPrice, buildEip3009TypedData, classifySettlement, parseSettlementResponse, usdToAtomic, type Eip3009Authorization, type X402PaymentHeaders as SharedX402PaymentHeaders, type X402PaymentPayload, type X402PaymentRequirements, type X402Quote, type X402Resource, type X402Signer, type VapiConfig } from "@vapi-network/core";
+import type { Hex } from "viem";
+export { EIP3009_AUTHORIZATION_TYPES, X402Error, assertMaxPrice, buildEip3009TypedData, classifySettlement, parseSettlementResponse, usdToAtomic, };
+export type { Eip3009Authorization, X402PaymentPayload, X402PaymentRequirements, X402Quote, X402Resource, };
+export type X402PaymentHeaders = SharedX402PaymentHeaders & {
+    "X-PAYMENT": string;
+};
+export declare function parse402Challenge(challenge: unknown, configuredNetworks: VapiConfig["networks"], fallbackResourceUrl?: string, requiredNetwork?: string, expectedPayTo?: string): X402Quote;
+export declare function parse402Response(response: Response, configuredNetworks: VapiConfig["networks"], requiredNetwork?: string, expectedPayTo?: string): Promise<X402Quote>;
+export declare function buildX402Payment(args: {
+    account: X402Signer;
+    quote: X402Quote;
+    nowSeconds?: number;
+    nonce?: Hex;
+    fetchImpl?: typeof fetch;
+}): Promise<{
+    payload: X402PaymentPayload;
+    headers: X402PaymentHeaders;
+}>;

package/package.json

@@ -1,38 +1,34 @@
 {
   "name": "@vapi-network/mcp",
-  "version": "0.1.1",
-  "description": "Agent Cash: a local-key MCP client for direct x402 payments",
-  "license": "MIT",
+  "version": "0.2.0",
+  "description": "Local, non-custodial MCP server for discovering and paying x402 APIs",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/vAPI-Network/vapi-app.git",
-    "directory": "packages/vapi-mcp"
+    "url": "git+https://github.com/vAPI-Network/vapi-network.git",
+    "directory": "packages/mcp"
+  },
+  "homepage": "https://github.com/vAPI-Network/vapi-network#readme",
+  "bugs": {
+    "url": "https://github.com/vAPI-Network/vapi-network/issues"
   },
   "type": "module",
   "sideEffects": false,
   "files": [
-    "dist",
-    "types",
-    "README.md"
+    "dist"
   ],
-  "bin": {
-    "vapi-mcp": "dist/cli.js"
-  },
   "exports": {
     ".": {
-      "types": "./types/server.d.ts",
-      "import": "./dist/server.js"
-    },
-    "./x402": {
-      "types": "./types/x402.d.ts",
-      "import": "./dist/x402.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
   "dependencies": {},
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "tag": "latest"
   }
 }