@vapi-network/mcp 0.7.0 → 0.8.0

package/README.md

@@ -2,7 +2,7 @@
 
 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, receipts and the status screen
+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.
@@ -19,6 +19,7 @@ One entry point, `@vapi-network/mcp`, exporting `createVapiServer`,
 | ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- |
 | `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 |
@@ -26,6 +27,7 @@ One entry point, `@vapi-network/mcp`, exporting `createVapiServer`,
 | `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 |
@@ -42,6 +44,8 @@ One entry point, `@vapi-network/mcp`, exporting `createVapiServer`,
 | `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 |
@@ -56,3 +60,9 @@ One entry point, `@vapi-network/mcp`, exporting `createVapiServer`,
 | `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

@@ -1,4 +1,4 @@
-import { type CeilingSweepHook, type SpendCaps, type VapiConfig, type VapiPaymentAccount } from "@vapi-network/core";
+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";
@@ -10,6 +10,7 @@ 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";
@@ -42,10 +43,10 @@ export declare const inspectToolResultSchema: z.ZodObject<{
     responseContentType: z.ZodOptional<z.ZodString>;
     network: z.ZodOptional<z.ZodString>;
     group: z.ZodOptional<z.ZodEnum<{
+        external: "external";
         vapi: "vapi";
         partner: "partner";
         added: "added";
-        external: "external";
     }>>;
     fee: z.ZodOptional<z.ZodObject<{
         bps: z.ZodNumber;
@@ -157,7 +158,7 @@ export declare const callSearch: import("./define.js").Action<{
             byline?: string | undefined;
             bylineHref?: string | undefined;
         };
-        group?: "partner" | "vapi" | "added" | "external" | undefined;
+        group?: "partner" | "external" | "vapi" | "added" | undefined;
         fee?: {
             [x: string]: unknown;
             bps: number;
@@ -221,7 +222,7 @@ export declare const callSearch: import("./define.js").Action<{
             byline?: string | undefined;
             bylineHref?: string | undefined;
         };
-        group?: "partner" | "vapi" | "added" | "external" | undefined;
+        group?: "partner" | "external" | "vapi" | "added" | undefined;
         fee?: {
             [x: string]: unknown;
             bps: number;
@@ -277,7 +278,7 @@ export declare const callSearch: import("./define.js").Action<{
             byline?: string | undefined;
             bylineHref?: string | undefined;
         };
-        group?: "partner" | "vapi" | "added" | "external" | undefined;
+        group?: "partner" | "external" | "vapi" | "added" | undefined;
         fee?: {
             [x: string]: unknown;
             bps: number;
@@ -333,7 +334,7 @@ export declare const callSearch: import("./define.js").Action<{
             byline?: string | undefined;
             bylineHref?: string | undefined;
         };
-        group?: "partner" | "vapi" | "added" | "external" | undefined;
+        group?: "partner" | "external" | "vapi" | "added" | undefined;
         fee?: {
             [x: string]: unknown;
             bps: number;
@@ -389,7 +390,7 @@ export declare const callInspect: import("./define.js").Action<{
     requestSchema?: unknown;
     responseContentType?: string | undefined;
     network?: string | undefined;
-    group?: "partner" | "vapi" | "added" | "external" | undefined;
+    group?: "partner" | "external" | "vapi" | "added" | undefined;
     fee?: {
         [x: string]: unknown;
         bps: number;
@@ -436,11 +437,15 @@ export declare const callPay: import("./define.js").Action<{
 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;

package/dist/actions/context.d.ts

@@ -1,9 +1,34 @@
-import type { AgentProfile, MarketplaceDiscoveryPage, VapiConfig } from "@vapi-network/core";
+import type { AgentProfile, MarketplaceDiscoveryPage, RunBudget, RunRef, TransferResult, VapiConfig } from "@vapi-network/core";
 import type { CallToolInput, CallToolResult } from "../tools/call.js";
 import type { InspectToolInput, InspectToolResult } from "../tools/inspect.js";
 import type { MarketplaceSearchInput } from "../tools/search.js";
+import type { SwarmRunInput, SwarmRunResult } from "../agent/swarm-run.js";
+import type { DetachedRunSummary, DetachedSwarmRunResult } from "../agent/runtime.js";
+import type { AccountsSendInput } from "./accounts.js";
+import type { CallReadInput, CallReadOutput } from "./call-read.js";
+import type { SwarmAddInput, SwarmDissolveInput, SwarmDissolveOutput, SwarmFundInput, SwarmFundOutput, SwarmLeaveInput, SwarmLeaveOutput, SwarmRebalanceInput, SwarmRebalanceOutput, SwarmSetupInput, SwarmSetupOutput, SwarmStatusInput, SwarmStatusOutput } from "./swarm.js";
 export type ActionSurface = "cli" | "mcp" | "agent";
+export type SwarmRunScope = {
+    name: string;
+    treasury: string;
+    member: string;
+    depth: 0 | 1;
+    draw: RunBudget;
+};
+export type SwarmRunActionInput = SwarmRunInput & {
+    detach?: boolean;
+};
+export type SwarmRunActionResult = SwarmRunResult | DetachedSwarmRunResult;
+export type SwarmRunsInput = {
+    name: string;
+};
+export type SwarmRunsResult = {
+    swarm: string;
+    runs: DetachedRunSummary[];
+};
 export type ActionRunState = {
+    ref?: RunRef;
+    swarm?: SwarmRunScope;
     searchedRefs: Set<string>;
     inspected: Map<string, InspectToolResult>;
     paidOrigins: Set<string>;
@@ -18,12 +43,33 @@ export type CallPort = {
     }): Promise<{
         wallet: string;
     } & CallToolResult>;
+    read?(input: CallReadInput): Promise<CallReadOutput>;
+};
+export type AccountsPort = {
+    send(input: AccountsSendInput): Promise<TransferResult>;
+};
+export type SwarmPort = {
+    setup(input: SwarmSetupInput): Promise<SwarmSetupOutput>;
+    add(input: SwarmAddInput): Promise<SwarmSetupOutput>;
+    leave(input: SwarmLeaveInput): Promise<SwarmLeaveOutput>;
+    fund(input: SwarmFundInput): Promise<SwarmFundOutput>;
+    rebalance(input: SwarmRebalanceInput): Promise<SwarmRebalanceOutput>;
+    status(input: SwarmStatusInput): Promise<SwarmStatusOutput>;
+    dissolve(input: SwarmDissolveInput): Promise<SwarmDissolveOutput>;
 };
 export type ActionContext = {
     config: VapiConfig;
     fetch?: typeof fetch;
     clock: () => Date;
     call: CallPort;
+    accounts?: AccountsPort;
+    swarm?: SwarmPort;
+    swarmRun?: {
+        run(input: SwarmRunActionInput): Promise<SwarmRunActionResult>;
+    };
+    swarmRuns?: {
+        list(input: SwarmRunsInput): Promise<SwarmRunsResult>;
+    };
     caps?: {
         perCallUsd: number;
     };