@vapi-network/mcp 0.2.2 → 0.3.0

package/dist/server.d.ts

@@ -1,8 +1,9 @@
-import { type VapiPaymentAccount, type VapiConfig } from "@vapi-network/core";
+import { type SecretStore, type VapiPaymentAccount, type VapiConfig, type WalletStore } 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 = {
+    /** The wallet unlocked before stdio was connected. */
     account: VapiPaymentAccount;
     config: VapiConfig;
     fetchImpl?: typeof fetch;
@@ -10,6 +11,15 @@ export type VapiServerOptions = {
     receiptsPath?: string;
     searchesPath?: string;
     reportsDirectory?: string;
+    /** The wallets on this machine. Without it the server has exactly one. */
+    store?: WalletStore | undefined;
+    /** The wallet the session starts on; `VAPI_WALLET` and the default follow. */
+    wallet?: string | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    /** The passphrase a payment unlocks with; see `WalletSession`. */
+    passphrase?: (() => string | Promise<string>) | undefined;
+    /** The OS secret store `vapi unlock` writes to; see `WalletSession`. */
+    secretStore?: SecretStore | undefined;
 };
 type ToolResult = {
     isError?: boolean;

package/dist/tools/call.d.ts

@@ -1,4 +1,4 @@
-import { type LookupFn, type MarketplaceHit, type VapiPaymentAccount, type VapiConfig } from "@vapi-network/core";
+import { type LookupFn, type MarketplaceHit, type SpendCaps, type VapiPaymentAccount, type VapiConfig, type WalletName } from "@vapi-network/core";
 export type CallToolInput = {
     id?: string;
     url?: string;
@@ -67,6 +67,10 @@ export type CallServiceArgs = {
     lookup?: LookupFn;
     ledgerPath?: string;
     receiptsPath?: string;
+    /** The wallet that pays, so its ledger row and its receipts stay its own. */
+    wallet?: WalletName;
+    /** The caps of that wallet. Without it, the machine-wide config caps apply. */
+    spendCaps?: SpendCaps;
     now?: Date;
     nowMs?: () => number;
     timeoutMs?: number;

package/dist/tools/wallet.d.ts

@@ -7,7 +7,19 @@ export type WalletBalance = {
     usdc: string | null;
     error?: string;
 };
-export declare function getWallet(account: Address | VapiPaymentAccount, config: VapiConfig, options?: {
+/**
+ * What a balance read needs to know about a wallet: its addresses, never its
+ * keys. A `VapiPaymentAccount` satisfies this, and so does the summary the
+ * wallet store reads out of a keystore without its passphrase — which is why
+ * `wallet.balance` can name another wallet without unlocking anything.
+ */
+export type WalletAddresses = {
+    address: Address;
+    solana?: {
+        address: string;
+    } | undefined;
+};
+export declare function getWallet(account: Address | WalletAddresses | VapiPaymentAccount, config: VapiConfig, options?: {
     fetchImpl?: typeof fetch;
     lookup?: LookupFn;
 }): Promise<{

package/dist/wallet-session.d.ts

@@ -0,0 +1,91 @@
+import { type SecretStore, type SpendCaps, type VapiPaymentAccount, type WalletName, type WalletStore } from "@vapi-network/core";
+import type { WalletAddresses } from "./tools/wallet.js";
+/** The wallet one tool call acts on. `path` is absent on a single-wallet home. */
+export type SessionWallet = {
+    name: WalletName;
+    /** The keystore file, when this machine has a wallet store. */
+    path?: string;
+};
+/** One row of `wallet.list`, before balances are read. */
+export type SessionWalletInfo = {
+    name: WalletName;
+    address?: string;
+    solanaAddress?: string;
+    label?: string;
+    isDefault: boolean;
+    /** Whether this is the wallet the session currently pays from. */
+    isActive: boolean;
+    spendCaps?: SpendCaps;
+};
+export type WalletSessionOptions = {
+    /** The wallet unlocked before stdio was connected, for a store-less home. */
+    account: VapiPaymentAccount;
+    /** The wallets on this machine. Without it the session has exactly one. */
+    store?: WalletStore | undefined;
+    /** The name the session starts on, before `VAPI_WALLET` and the default. */
+    wallet?: string | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    /**
+     * The passphrase a payment unlocks with when neither
+     * `VAPI_KEYSTORE_PASSWORD` nor the OS secret store has one. The CLI hands
+     * over what it read at startup — from the person who ran `vapi mcp` in a
+     * terminal — so switching wallets never needs a prompt on a stdout that
+     * belongs to MCP frames.
+     */
+    passphrase?: (() => string | Promise<string>) | undefined;
+    /** The OS secret store to read `vapi unlock` entries from. */
+    secretStore?: SecretStore | undefined;
+    now?: (() => Date) | undefined;
+};
+/**
+ * Which wallet an MCP session pays from, for the lifetime of the process.
+ *
+ * The session is the only mutable wallet state the server has, and it is
+ * deliberately memory-only: `wallet.use` moves it, and nothing in this package
+ * ever writes `wallets.json`, creates, removes, renames, backs up or exports a
+ * wallet. Reads — addresses, balances, accounts, funding links — need no
+ * passphrase at all, because the wallet store can read a keystore's addresses
+ * without opening it. Only a payment unlocks a key, once, for that one call.
+ */
+export declare class WalletSession {
+    #private;
+    private readonly options;
+    constructor(options: WalletSessionOptions);
+    /** The wallet the next tool call uses when it names none. */
+    get activeName(): WalletName | undefined;
+    get store(): WalletStore | undefined;
+    /** The home the audit log lives in, honouring `VAPI_HOME`. */
+    get home(): string;
+    /**
+     * An explicit name first, then the session's active wallet — which already
+     * absorbed `VAPI_WALLET` and the registry default when the session started.
+     */
+    resolve(name?: string): SessionWallet;
+    /** The addresses of a wallet, read straight out of its keystore header. */
+    addressesFor(name?: string): Promise<{
+        wallet: SessionWallet;
+    } & WalletAddresses>;
+    /**
+     * The unlocked key for one payment, plus the caps of that wallet. Nothing
+     * here is cached: the account is created for this call and dropped with it,
+     * so switching wallets mid-session pays from the wallet that was asked for.
+     */
+    payment(name?: string): Promise<{
+        wallet: SessionWallet;
+        account: VapiPaymentAccount;
+        spendCaps?: SpendCaps;
+    }>;
+    /** Every wallet this machine knows, with the session's own marker on one. */
+    list(): Promise<SessionWalletInfo[]>;
+    /**
+     * Points the session at another wallet. Memory only: the human's default in
+     * `wallets.json` is not touched, so the next `vapi` command in their terminal
+     * still uses the wallet they chose. The switch is audited, because the wallet
+     * an agent pays from changed.
+     */
+    use(name: string): Promise<{
+        active: WalletName;
+        address?: string;
+        previous: WalletName | null;
+    }>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vapi-network/mcp",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Local, non-custodial MCP server for discovering and paying x402 APIs",
   "license": "Apache-2.0",
   "repository": {
@@ -15,7 +15,8 @@
   "type": "module",
   "sideEffects": false,
   "files": [
-    "dist"
+    "dist",
+    "README.md"
   ],
   "exports": {
     ".": {