@vapi-network/mcp 0.5.0 → 0.8.0

package/README.md

@@ -2,13 +2,67 @@
 
 The stdio MCP server behind `vapi mcp`: namespaced tools that let an agent
 search the vAPI catalogue, read a listing's request contract, pay an x402 API
-from a local wallet, and read balances and receipts. It never creates, renames,
-removes, backs up or exports a wallet, and no tool of its returns a recovery
-phrase, a private key or a passphrase.
+from a local wallet, read paid origins during an agent run, and read balances, receipts and the status screen
+(`vapi.status`, `vapi.accounts`, `vapi.siblings`). It can derive an account and lower its caps,
+but it never renames, removes, backs up or exports one, and no tool returns a
+recovery phrase, private key or passphrase.
 
 One entry point, `@vapi-network/mcp`, exporting `createVapiServer`,
 `startStdioServer`, `loadServerConfig`, `WalletSession` and the individual
 `callService`, `inspectService`, `searchMarketplace` and `getWallet` tools.
 
-See the [root README](https://github.com/vAPI-Network/vapi-network#readme) for
-the editor configuration, the full tool table and the deprecated aliases.
+## Exports
+
+### Runtime exports
+
+| Name                     | What it is                                                                                                                                                                                                                                                           | Since            |
+| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- |
+| `buildSIWxProof`         | function (args: { signer: SIWxSigner; challenge: SIWxChallenge; responseUrl: string; }): unknown                                                                                                                                                                     | 0.5.0 or earlier |
+| `callService`            | function (args: CallServiceArgs): Promise<CallToolResult>                                                                                                                                                                                                            | 0.5.0 or earlier |
+| `callRead`               | action `call.read`: GET an HTTPS URL from an origin paid in the current agent run; SIWX sign-in is allowed, but it never pays                                                                                                                                        | 0.8.0            |
+| `createAgentRunDeps`     | function (input: { profile: AgentProfile; config: VapiConfig; home: string; account: VapiPaymentAccount; wallet: WalletName; spendCaps: SpendCaps; chat: (req: ChatRequest) => Promise<ChatResult>; approve: RunAgentDeps["approve"]; onEvent?: (event: AgentEven... | 0.5.0 or earlier |
+| `createVapiServer`       | function (options: VapiServerOptions): unknown                                                                                                                                                                                                                       | 0.5.0 or earlier |
+| `decidePayment`          | function (input: { ref: string; priceUsd: number \| null; verification: string; seenRefs: ReadonlySet<string>; verifiedOnly: boolean; approveAboveUsd: number; maxPerCallUsd: number; }): PayDecision                                                                | 0.5.0 or earlier |
+| `getWallet`              | function (account: Address \| WalletAddresses \| VapiPaymentAccount, config: VapiConfig, options: { fetchImpl?: typeof fetch; lookup?: LookupFn } = {}): Promise<{ address: Address; balances: WalletBalance[] }>                                                    | 0.5.0 or earlier |
+| `inspectService`         | function (input: InspectToolInput, config: VapiConfig, fetchImpl?: typeof fetch): Promise<InspectToolResult>                                                                                                                                                         | 0.5.0 or earlier |
+| `loadServerConfig`       | function (): unknown                                                                                                                                                                                                                                                 | 0.5.0 or earlier |
+| `parseSIWxResponse`      | function (response: Response, configuredNetworks: VapiConfig["networks"], responseUrl: string, requiredNetwork?: string): Promise<SIWxChallenge \| null>                                                                                                             | 0.5.0 or earlier |
+| `readPaidOrigin`         | function (args: { url; paidOrigins; account; config; fetchImpl?; lookup?; timeoutMs? }): Promise<CallReadOutput>                                                                                                                                                     | 0.8.0            |
+| `resolveServiceEndpoint` | function (id: string, config: VapiRegistryConfig, fetchImpl?: Fetch, endpointName?: string): Promise<DiscoveryEndpoint>                                                                                                                                              | 0.5.0 or earlier |
+| `resolveServiceListing`  | function (id: string, config: VapiRegistryConfig, fetchImpl?: Fetch, endpointName?: string): Promise<ResolvedListing>                                                                                                                                                | 0.5.0 or earlier |
+| `runAgent`               | function (task: string, deps: RunAgentDeps): Promise<RunAgentResult>                                                                                                                                                                                                 | 0.5.0 or earlier |
+| `searchMarketplace`      | function (input: MarketplaceSearchInput, config: VapiRegistryConfig, fetchImpl?: Fetch, options?: MarketplaceSearchOptions): Promise<MarketplaceDiscoveryPage>                                                                                                       | 0.5.0 or earlier |
+| `startStdioServer`       | function (options: VapiServerOptions): unknown                                                                                                                                                                                                                       | 0.5.0 or earlier |
+| `UNTRUSTED_NOTICE`       | constant UNTRUSTED_NOTICE: string                                                                                                                                                                                                                                    | 0.5.0 or earlier |
+| `WalletSession`          | class WalletSession                                                                                                                                                                                                                                                  | 0.5.0 or earlier |
+| `wrapUntrusted`          | function (tool: string, value: unknown): string                                                                                                                                                                                                                      | 0.5.0 or earlier |
+
+### Types
+
+| Name                     | What it is                                                                                                                                                                                                                                                                                           | Since            |
+| ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- |
+| `AgentEvent`             | type AgentEvent = \| { type: "step"; n: number } \| { type: "tool"; name: string; summary: string } \| { type: "paid"; ref: string; amountUsd: number; network: string } \| { type: "declined"; ref: string; reason: string } \| { type: "stopped"; reason: "finished"...                            | 0.5.0 or earlier |
+| `CallToolInput`          | type CallToolInput = { id?: string; url?: string; method?: string; endpoint?: string; body?: unknown; maxPriceUsd?: number \| string; network?: string; expectedPayTo?: string; contentType?: string; }                                                                                              | 0.5.0 or earlier |
+| `CallToolResult`         | type CallToolResult = { status: number; body: unknown; verification?: ListingVerification; outcome?: "signed_in"; payment: null \| { network: string; amountAtomic: string; amountUsd: string; asset: string; payTo: string; settlement: unknown \| null; proof: st...                               | 0.5.0 or earlier |
+| `CallReadInput`          | type CallReadInput = { url: string }                                                                                                                                                                                                                                                                 | 0.8.0            |
+| `CallReadOutput`         | type CallReadOutput = { status: number; contentType: string \| null; body: unknown }                                                                                                                                                                                                                 | 0.8.0            |
+| `InspectToolInput`       | type InspectToolInput = { id: string; endpoint?: string; }                                                                                                                                                                                                                                           | 0.5.0 or earlier |
+| `InspectToolResult`      | type InspectToolResult = Omit< Pick< DiscoveryEndpoint, \| "name" \| "method" \| "url" \| "price" \| "description" \| "operationId" \| "requestContentType" \| "requestSchema" \| "responseContentType" >, "method" > & { method: string \| null; network?: string; group?:...                       | 0.5.0 or earlier |
+| `MarketplaceSearchInput` | type MarketplaceSearchInput = { query?: string; kinds?: MarketplaceKind[]; network?: string; limit?: number; cursor?: string; includeUnverified?: boolean; }                                                                                                                                         | 0.5.0 or earlier |
+| `PayDecision`            | type PayDecision = { action: "pay" } \| { action: "ask"; reason: string } \| { action: "refuse"; reason: string }                                                                                                                                                                                    | 0.5.0 or earlier |
+| `RunAgentDeps`           | type RunAgentDeps = { profile: AgentProfile; config: VapiConfig; home: string; chat: (req: ChatRequest) => Promise<ChatResult>; search: (q: { query: string; network?: string; includeUnverified: boolean }) => Promise< Array<{ ref: string; name: string; price...                                 | 0.5.0 or earlier |
+| `RunAgentResult`         | type RunAgentResult = { answer: string \| null; stoppedBecause: AgentEvent & { type: "stopped" }; paidUsd: number; steps: number; }                                                                                                                                                                  | 0.5.0 or earlier |
+| `SessionWallet`          | type SessionWallet = { name: WalletName; path?: string; }                                                                                                                                                                                                                                            | 0.5.0 or earlier |
+| `SessionWalletInfo`      | type SessionWalletInfo = { name: WalletName; address?: string; solanaAddress?: string; label?: string; isDefault: boolean; isActive: boolean; spendCaps?: SpendCaps; }                                                                                                                               | 0.5.0 or earlier |
+| `VapiServerOptions`      | type VapiServerOptions = { account: VapiPaymentAccount; config: VapiConfig; fetchImpl?: typeof fetch; ledgerPath?: string; receiptsPath?: string; searchesPath?: string; reportsDirectory?: string; store?: WalletStore \| undefined; wallet?: string \| undefined; status?: StatusCoreOverrides;... | 0.5.0 or earlier |
+| `WalletAddresses`        | type WalletAddresses = { address: Address; solana?: { address: string } \| undefined; }                                                                                                                                                                                                              | 0.5.0 or earlier |
+| `WalletBalance`          | type WalletBalance = { network: string; name: string; usdcAtomic: string \| null; usdc: string \| null; error?: string; }                                                                                                                                                                            | 0.5.0 or earlier |
+| `WalletSessionOptions`   | type WalletSessionOptions = { account: VapiPaymentAccount; store?: WalletStore \| undefined; wallet?: string \| undefined; env?: NodeJS.ProcessEnv \| undefined; passphrase?: (() => string \| Promise<string>) \| undefined; secretStore?: SecretStore \| undefined; n...                           | 0.5.0 or earlier |
+
+See the [root README](https://github.com/vAPI-Network/vapi-network/blob/main/docs/mcp.md) for the editor configuration, the full tool table and the deprecated aliases.
+
+`call.read` is available to agent runs with the `read` grant. It only sends
+GET requests to HTTPS origins that the same agent paid in the current run,
+follows guarded redirects, and never makes another payment. A 402 may be
+retried once with a SIWX sign-in proof bound to that origin. The MCP surface
+lists the tool for schema alignment, but calls outside an agent run are refused.

package/dist/actions/accounts.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+export declare const accountsSendInputSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    amountUsd: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    network: z.ZodOptional<z.ZodEnum<{
+        base: "base";
+        arc: "arc";
+    }>>;
+}, z.core.$strip>;
+export type AccountsSendInput = z.infer<typeof accountsSendInputSchema>;
+export declare const accountsSendOutputSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        sent: "sent";
+    }>;
+    from: z.ZodString;
+    to: z.ZodString;
+    toName: z.ZodString;
+    toKind: z.ZodEnum<{
+        account: "account";
+        owner: "owner";
+    }>;
+    amountUsd: z.ZodString;
+    amountAtomic: z.ZodString;
+    network: z.ZodEnum<{
+        "eip155:8453": "eip155:8453";
+        "eip155:5042": "eip155:5042";
+    }>;
+    txHash: z.ZodNullable<z.ZodString>;
+    nonce: z.ZodString;
+    replayed: z.ZodBoolean;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const accountsSend: import("./define.js").Action<{
+    from: string;
+    to: string;
+    amountUsd: string | number;
+    network?: "base" | "arc" | undefined;
+}, {
+    status: "unknown" | "sent";
+    from: string;
+    to: string;
+    toName: string;
+    toKind: "account" | "owner";
+    amountUsd: string;
+    amountAtomic: string;
+    network: "eip155:8453" | "eip155:5042";
+    txHash: string | null;
+    nonce: string;
+    replayed: boolean;
+    message: string;
+}>;

package/dist/actions/call-read.d.ts

@@ -0,0 +1,28 @@
+import { type LookupFn, type VapiConfig, type VapiPaymentAccount } from "@vapi-network/core";
+import { z } from "zod";
+export declare const callReadInputSchema: z.ZodObject<{
+    url: z.ZodString;
+}, z.core.$strip>;
+export declare const callReadOutputSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    contentType: z.ZodNullable<z.ZodString>;
+    body: z.ZodUnknown;
+}, z.core.$strip>;
+export type CallReadInput = z.infer<typeof callReadInputSchema>;
+export type CallReadOutput = z.infer<typeof callReadOutputSchema>;
+export declare const callRead: import("./define.js").Action<{
+    url: string;
+}, {
+    status: number;
+    contentType: string | null;
+    body: unknown;
+}>;
+export declare function readPaidOrigin(args: {
+    url: string;
+    paidOrigins: ReadonlySet<string>;
+    account: VapiPaymentAccount;
+    config: VapiConfig;
+    fetchImpl?: typeof fetch;
+    lookup?: LookupFn;
+    timeoutMs?: number;
+}): Promise<CallReadOutput>;

package/dist/actions/call.d.ts

@@ -0,0 +1,458 @@
+import { type CeilingSweepHook, type RunBudget, type RunRef, type SpendCaps, type VapiConfig, type VapiPaymentAccount } from "@vapi-network/core";
+import { z } from "zod";
+import { type CallToolResult } from "../tools/call.js";
+import { type CallPort } from "./context.js";
+export declare const MAX_CACHED_MARKETPLACE_REFS = 200;
+export declare const walletArgument: {
+    wallet: z.ZodOptional<z.ZodString>;
+};
+export declare const callToolResultSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    status: z.ZodNumber;
+    body: z.ZodUnknown;
+    resourceUrl: z.ZodOptional<z.ZodURL>;
+    verification: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        requested: "requested";
+        verified: "verified";
+    }>>;
+    payment: z.ZodNullable<z.ZodObject<{
+        network: z.ZodString;
+        amountAtomic: z.ZodString;
+        amountUsd: z.ZodString;
+        asset: z.ZodString;
+        payTo: z.ZodString;
+        settlement: z.ZodNullable<z.ZodUnknown>;
+        proof: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    outcome: z.ZodOptional<z.ZodLiteral<"signed_in">>;
+    expectedRequest: z.ZodOptional<z.ZodObject<{
+        contentType: z.ZodOptional<z.ZodString>;
+        schema: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const inspectToolResultSchema: z.ZodObject<{
+    name: z.ZodString;
+    method: z.ZodNullable<z.ZodString>;
+    url: z.ZodURL;
+    price: z.ZodString;
+    description: z.ZodString;
+    operationId: z.ZodOptional<z.ZodString>;
+    requestContentType: z.ZodOptional<z.ZodString>;
+    requestSchema: z.ZodOptional<z.ZodUnknown>;
+    responseContentType: z.ZodOptional<z.ZodString>;
+    network: z.ZodOptional<z.ZodString>;
+    group: z.ZodOptional<z.ZodEnum<{
+        external: "external";
+        vapi: "vapi";
+        partner: "partner";
+        added: "added";
+    }>>;
+    fee: z.ZodOptional<z.ZodObject<{
+        bps: z.ZodNumber;
+        label: z.ZodString;
+    }, z.core.$loose>>;
+    verification: z.ZodEnum<{
+        none: "none";
+        requested: "requested";
+        verified: "verified";
+    }>;
+    liveness: z.ZodOptional<z.ZodObject<{
+        uptime7d: z.ZodNumber;
+        latencyP50Ms: z.ZodNullable<z.ZodNumber>;
+        latencyP95Ms: z.ZodNullable<z.ZodNumber>;
+        checks7d: z.ZodNumber;
+    }, z.core.$loose>>;
+    conformance: z.ZodOptional<z.ZodObject<{
+        declaredVersion: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+        versionConformant: z.ZodBoolean;
+        offerTransport: z.ZodEnum<{
+            body: "body";
+            header: "header";
+            both: "both";
+        }>;
+        issues: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>>;
+    identity: z.ZodOptional<z.ZodObject<{
+        erc8004Id: z.ZodString;
+        reputation: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+            score: z.ZodNumber;
+            count: z.ZodNumber;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+    payment: z.ZodNullable<z.ZodObject<{
+        scheme: z.ZodLiteral<"exact">;
+        network: z.ZodString;
+        asset: z.ZodString;
+        payTo: z.ZodString;
+        checkedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const callSearchInputSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    kinds: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        api: "api";
+        service_offer: "service_offer";
+        open_request: "open_request";
+    }>>>;
+    network: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    includeUnverified: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const callInspectInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    endpoint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const callPayInputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodURL>;
+    method: z.ZodOptional<z.ZodString>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodUnknown>;
+    contentType: z.ZodOptional<z.ZodString>;
+    network: z.ZodOptional<z.ZodString>;
+    expectedPayTo: z.ZodOptional<z.ZodString>;
+    maxPriceUsd: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    wallet: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const callSearch: import("./define.js").Action<{
+    query?: string | undefined;
+    kinds?: ("api" | "service_offer" | "open_request")[] | undefined;
+    network?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    includeUnverified?: boolean | undefined;
+}, {
+    [x: string]: unknown;
+    protocol: "vapi.marketplace.discovery/1";
+    items: ({
+        [x: string]: unknown;
+        kind: "api";
+        provenance: "self_listed" | "partner";
+        execution: {
+            [x: string]: unknown;
+            mode: "direct" | "gateway";
+        };
+        action: {
+            [x: string]: unknown;
+            type: "invoke_api";
+            href: string;
+        };
+        verification: "none" | "requested" | "verified";
+        ref: string;
+        card: {
+            [x: string]: unknown;
+            title: string;
+            summary: string;
+            badges: {
+                [x: string]: unknown;
+                code: "partner" | "live_x402" | "payout_wallet_confirmed" | "vapi_verified" | "external_catalog" | "approved_vendor";
+                label: string;
+            }[];
+            facts: {
+                [x: string]: unknown;
+                label: string;
+                value: string;
+            }[];
+            byline?: string | undefined;
+            bylineHref?: string | undefined;
+        };
+        group?: "partner" | "external" | "vapi" | "added" | undefined;
+        fee?: {
+            [x: string]: unknown;
+            bps: number;
+            label: string;
+        } | undefined;
+        liveness?: {
+            [x: string]: unknown;
+            uptime7d: number;
+            latencyP50Ms: number | null;
+            latencyP95Ms: number | null;
+            checks7d: number;
+        } | undefined;
+        conformance?: {
+            [x: string]: unknown;
+            declaredVersion: 1 | 2 | null;
+            versionConformant: boolean;
+            offerTransport: "body" | "header" | "both";
+            issues: string[];
+        } | undefined;
+        identity?: {
+            [x: string]: unknown;
+            erc8004Id: string;
+            reputation?: {
+                [x: string]: unknown;
+                score: number;
+                count: number;
+            } | undefined;
+        } | undefined;
+    } | {
+        [x: string]: unknown;
+        kind: "api";
+        provenance: "indexed";
+        execution: {
+            [x: string]: unknown;
+            mode: "direct";
+            url: string;
+            method: "HEAD" | "POST" | "GET" | "PUT" | "PATCH" | "DELETE" | null;
+            network: string;
+        };
+        action: {
+            [x: string]: unknown;
+            type: "invoke_api";
+            href: string;
+        };
+        verification: "none" | "requested" | "verified";
+        ref: string;
+        card: {
+            [x: string]: unknown;
+            title: string;
+            summary: string;
+            badges: {
+                [x: string]: unknown;
+                code: "partner" | "live_x402" | "payout_wallet_confirmed" | "vapi_verified" | "external_catalog" | "approved_vendor";
+                label: string;
+            }[];
+            facts: {
+                [x: string]: unknown;
+                label: string;
+                value: string;
+            }[];
+            byline?: string | undefined;
+            bylineHref?: string | undefined;
+        };
+        group?: "partner" | "external" | "vapi" | "added" | undefined;
+        fee?: {
+            [x: string]: unknown;
+            bps: number;
+            label: string;
+        } | undefined;
+        liveness?: {
+            [x: string]: unknown;
+            uptime7d: number;
+            latencyP50Ms: number | null;
+            latencyP95Ms: number | null;
+            checks7d: number;
+        } | undefined;
+        conformance?: {
+            [x: string]: unknown;
+            declaredVersion: 1 | 2 | null;
+            versionConformant: boolean;
+            offerTransport: "body" | "header" | "both";
+            issues: string[];
+        } | undefined;
+        identity?: {
+            [x: string]: unknown;
+            erc8004Id: string;
+            reputation?: {
+                [x: string]: unknown;
+                score: number;
+                count: number;
+            } | undefined;
+        } | undefined;
+    } | {
+        [x: string]: unknown;
+        kind: "service_offer";
+        action: {
+            [x: string]: unknown;
+            type: "start_engagement";
+            href: string;
+        };
+        verification: "none" | "requested" | "verified";
+        ref: string;
+        card: {
+            [x: string]: unknown;
+            title: string;
+            summary: string;
+            badges: {
+                [x: string]: unknown;
+                code: "partner" | "live_x402" | "payout_wallet_confirmed" | "vapi_verified" | "external_catalog" | "approved_vendor";
+                label: string;
+            }[];
+            facts: {
+                [x: string]: unknown;
+                label: string;
+                value: string;
+            }[];
+            byline?: string | undefined;
+            bylineHref?: string | undefined;
+        };
+        group?: "partner" | "external" | "vapi" | "added" | undefined;
+        fee?: {
+            [x: string]: unknown;
+            bps: number;
+            label: string;
+        } | undefined;
+        liveness?: {
+            [x: string]: unknown;
+            uptime7d: number;
+            latencyP50Ms: number | null;
+            latencyP95Ms: number | null;
+            checks7d: number;
+        } | undefined;
+        conformance?: {
+            [x: string]: unknown;
+            declaredVersion: 1 | 2 | null;
+            versionConformant: boolean;
+            offerTransport: "body" | "header" | "both";
+            issues: string[];
+        } | undefined;
+        identity?: {
+            [x: string]: unknown;
+            erc8004Id: string;
+            reputation?: {
+                [x: string]: unknown;
+                score: number;
+                count: number;
+            } | undefined;
+        } | undefined;
+    } | {
+        [x: string]: unknown;
+        kind: "open_request";
+        action: {
+            [x: string]: unknown;
+            type: "propose_to_request";
+            href: string;
+        };
+        verification: "none" | "requested" | "verified";
+        ref: string;
+        card: {
+            [x: string]: unknown;
+            title: string;
+            summary: string;
+            badges: {
+                [x: string]: unknown;
+                code: "partner" | "live_x402" | "payout_wallet_confirmed" | "vapi_verified" | "external_catalog" | "approved_vendor";
+                label: string;
+            }[];
+            facts: {
+                [x: string]: unknown;
+                label: string;
+                value: string;
+            }[];
+            byline?: string | undefined;
+            bylineHref?: string | undefined;
+        };
+        group?: "partner" | "external" | "vapi" | "added" | undefined;
+        fee?: {
+            [x: string]: unknown;
+            bps: number;
+            label: string;
+        } | undefined;
+        liveness?: {
+            [x: string]: unknown;
+            uptime7d: number;
+            latencyP50Ms: number | null;
+            latencyP95Ms: number | null;
+            checks7d: number;
+        } | undefined;
+        conformance?: {
+            [x: string]: unknown;
+            declaredVersion: 1 | 2 | null;
+            versionConformant: boolean;
+            offerTransport: "body" | "header" | "both";
+            issues: string[];
+        } | undefined;
+        identity?: {
+            [x: string]: unknown;
+            erc8004Id: string;
+            reputation?: {
+                [x: string]: unknown;
+                score: number;
+                count: number;
+            } | undefined;
+        } | undefined;
+    })[];
+    nextCursor: string | null;
+    unavailableKinds: ("api" | "service_offer" | "open_request")[];
+    rankingVersion: "marketplace-ranking-v1";
+}>;
+export declare const callInspect: import("./define.js").Action<{
+    id: string;
+    endpoint?: string | undefined;
+}, {
+    name: string;
+    method: string | null;
+    url: string;
+    price: string;
+    description: string;
+    verification: "none" | "requested" | "verified";
+    payment: {
+        scheme: "exact";
+        network: string;
+        asset: string;
+        payTo: string;
+        checkedAt: string;
+    } | null;
+    operationId?: string | undefined;
+    requestContentType?: string | undefined;
+    requestSchema?: unknown;
+    responseContentType?: string | undefined;
+    network?: string | undefined;
+    group?: "partner" | "external" | "vapi" | "added" | undefined;
+    fee?: {
+        [x: string]: unknown;
+        bps: number;
+        label: string;
+    } | undefined;
+    liveness?: {
+        [x: string]: unknown;
+        uptime7d: number;
+        latencyP50Ms: number | null;
+        latencyP95Ms: number | null;
+        checks7d: number;
+    } | undefined;
+    conformance?: {
+        [x: string]: unknown;
+        declaredVersion: 1 | 2 | null;
+        versionConformant: boolean;
+        offerTransport: "body" | "header" | "both";
+        issues: string[];
+    } | undefined;
+    identity?: {
+        [x: string]: unknown;
+        erc8004Id: string;
+        reputation?: {
+            [x: string]: unknown;
+            score: number;
+            count: number;
+        } | undefined;
+    } | undefined;
+}>;
+export declare const callPay: import("./define.js").Action<{
+    id?: string | undefined;
+    url?: string | undefined;
+    method?: string | undefined;
+    endpoint?: string | undefined;
+    body?: unknown;
+    contentType?: string | undefined;
+    network?: string | undefined;
+    expectedPayTo?: string | undefined;
+    maxPriceUsd?: string | number | undefined;
+    wallet?: string | undefined;
+}, {
+    wallet: string;
+} & CallToolResult>;
+export type PaymentResolution = {
+    account: VapiPaymentAccount;
+    wallet: string;
+    runBudget?: RunBudget;
+    run?: RunRef;
+    spendCaps?: SpendCaps;
+    ledgerPath: string;
+    receiptsPath: string;
+    fetchImpl?: typeof fetch;
+    ceilingSweep?: CeilingSweepHook | false;
+    now?: Date;
+    allowanceExpiresAt?: Date;
+};
+export type CreateCallPortOptions = {
+    config: VapiConfig;
+    fetchImpl?: typeof fetch;
+    searchesPath?: string;
+    notice?: (message: string) => void;
+    cacheMarketplaceHits?: boolean | "optional";
+    resolvePayment: (wallet?: string) => Promise<PaymentResolution>;
+};
+export declare function createCallPort(options: CreateCallPortOptions): CallPort;