@vapi-network/mcp 0.7.0 → 0.9.0

package/dist/agent/deps.d.ts

@@ -1,4 +1,4 @@
-import { type AgentProfile, type CeilingSweepHook, type ChatRequest, type ChatResult, type SpendCaps, type VapiConfig, type VapiPaymentAccount, type WalletName } from "@vapi-network/core";
+import { type AgentProfile, type CeilingSweepHook, type ChatRequest, type ChatResult, type RunBudget, type SpendCaps, type VapiConfig, type VapiPaymentAccount, type WalletName } from "@vapi-network/core";
 import type { AgentEvent, RunAgentDeps } from "./run.js";
 export declare function createAgentRunDeps(input: {
     profile: AgentProfile;
@@ -7,6 +7,7 @@ export declare function createAgentRunDeps(input: {
     account: VapiPaymentAccount;
     wallet: WalletName;
     spendCaps: SpendCaps;
+    currentSpendCaps?: () => Promise<SpendCaps>;
     chat: (req: ChatRequest) => Promise<ChatResult>;
     approve: RunAgentDeps["approve"];
     onEvent?: (event: AgentEvent) => void;
@@ -15,4 +16,13 @@ export declare function createAgentRunDeps(input: {
     ledgerPath?: string;
     receiptsPath?: string;
     ceilingSweep?: CeilingSweepHook | false;
+    budget?: RunBudget;
+    now?: () => Date;
+    allowanceExpiresAt?: Date;
+    runId?: string;
+    runMeta?: {
+        swarm?: string;
+        member?: string;
+        parentRunId?: string;
+    };
 }): RunAgentDeps;

package/dist/agent/guards.d.ts

@@ -1,3 +1,4 @@
+export { decideFunding, decideRelease, type FundingDecision, type ReleaseDecision, } from "@vapi-network/core";
 export declare const UNTRUSTED_NOTICE: string;
 /** Wraps tool output so the model can tell data from instructions. */
 export declare function wrapUntrusted(tool: string, value: unknown): string;

package/dist/agent/run.d.ts

@@ -1,5 +1,8 @@
-import { type AgentProfile, type ChatRequest, type ChatResult, type VapiConfig } from "@vapi-network/core";
-import { type ActionRunState } from "../actions/context.js";
+import { type AgentProfile, type ChatRequest, type ChatResult, type RunBudget, type VapiConfig } from "@vapi-network/core";
+import { type CallReadOutput } from "../actions/call-read.js";
+import { type ActionRunState, type SwarmRunScope } from "../actions/context.js";
+import { actions } from "../actions/register.js";
+import { type SwarmAllocateResult, type SwarmDelegateResult } from "../actions/swarm-agent.js";
 import type { InspectToolResult } from "../tools/inspect.js";
 export type AgentEvent = {
     type: "step";
@@ -19,9 +22,23 @@ export type AgentEvent = {
     reason: string;
 } | {
     type: "stopped";
-    reason: "finished" | "max_steps" | "router_budget" | "paused" | "error";
+    reason: "finished" | "max_steps" | "router_budget" | "run_budget" | "paused" | "error";
     detail?: string;
 };
+export type SwarmRunContext = SwarmRunScope & {
+    allocate(input: {
+        amountUsd: string;
+        reason?: string;
+        requestId: string;
+    }): Promise<SwarmAllocateResult>;
+    delegate(input: {
+        member: string;
+        task: string;
+        budgetUsd: string;
+        parentRunId: string;
+        requestId: string;
+    }): Promise<SwarmDelegateResult>;
+};
 export type RunAgentDeps = {
     profile: AgentProfile;
     config: VapiConfig;
@@ -39,6 +56,9 @@ export type RunAgentDeps = {
         description?: string;
     }>>;
     inspect: (ref: string) => Promise<InspectToolResult>;
+    read?: (input: {
+        url: string;
+    }) => Promise<CallReadOutput>;
     pay: (input: {
         ref: string;
         body?: unknown;
@@ -61,18 +81,37 @@ export type RunAgentDeps = {
     onEvent?: (event: AgentEvent) => void;
     tty?: boolean;
     now?: () => Date;
+    budget?: RunBudget;
+    runId?: string;
+    runMeta?: {
+        swarm?: string;
+        member?: string;
+        parentRunId?: string;
+    };
+    swarm?: SwarmRunContext;
     forRun?: (run: ActionRunState) => RunAgentDeps;
 };
 export type RunAgentResult = {
+    runId: string;
     answer: string | null;
     stoppedBecause: AgentEvent & {
         type: "stopped";
     };
     paidUsd: number;
     steps: number;
+    budget?: {
+        limitUsd: number;
+        spentUsd: number;
+    };
 };
+type RegisteredAction = (typeof actions)[number];
+export declare function loopActionsFor(profile: {
+    tools: readonly string[];
+    grants?: readonly string[];
+}): RegisteredAction[];
 export declare function loopToolsForProfile(profile: {
     tools: readonly string[];
+    grants?: readonly string[];
 }): ({
     readonly type: "function";
     readonly function: {
@@ -106,3 +145,4 @@ export declare function loopToolsForProfile(profile: {
     };
 })[];
 export declare function runAgent(task: string, deps: RunAgentDeps): Promise<RunAgentResult>;
+export {};

package/dist/agent/runtime.d.ts

@@ -0,0 +1,154 @@
+import { type AgentProfile, type WalletStore } from "@vapi-network/core";
+import { z } from "zod";
+import { type SwarmRunResult } from "./swarm-run.js";
+import type { RunAgentResult } from "./run.js";
+export type RuntimeKind = "local" | "railway";
+export type RuntimeMember = {
+    swarm?: string;
+    account: string;
+    profile: string;
+    role?: string;
+};
+export type RuntimeRun = {
+    runId: string;
+    task: string;
+    mode: "agent" | "lead";
+    budgetUsd?: string;
+    drawUsd?: string;
+    parentRunId?: string;
+};
+export type RuntimeHandle = {
+    runId: string;
+    kind: RuntimeKind;
+    member: RuntimeMember;
+    startedAt: string;
+    /** Adapter-specific process or sandbox reference. It must never contain a secret. */
+    ref: string;
+};
+export type RuntimeStatus = {
+    state: "running" | "finished" | "failed" | "stopped" | "unknown";
+    /** Adapters may return unknown parsed result-file content. */
+    result?: RunAgentResult | SwarmRunResult | unknown;
+    exitCode?: number;
+    detail?: string;
+};
+export interface Runtime {
+    kind: RuntimeKind;
+    /** An adapter-owned unresolved start that must block another member worker. */
+    busy?(member: RuntimeMember): Promise<{
+        runId: string;
+        detail: string;
+    } | undefined>;
+    start(member: RuntimeMember, run: RuntimeRun, 
+    /** Persist this reference before the adapter continues a multi-step launch. */
+    persistLaunch?: (handle: RuntimeHandle) => Promise<void>): Promise<RuntimeHandle>;
+    /** Recover an adapter-owned reference after the launcher crashed before saving it. */
+    recover?(record: RunRecord): Promise<RuntimeHandle | undefined>;
+    /** Retire this exact adapter-owned start after the owner confirms its worker is gone. */
+    retireUnreconciledStart?(record: RunRecord): Promise<void>;
+    stop(handle: RuntimeHandle): Promise<void>;
+    status(handle: RuntimeHandle): Promise<RuntimeStatus>;
+}
+export type RunState = RuntimeStatus["state"] | "starting";
+export declare class RuntimeError extends Error {
+    readonly code: "member_busy" | "runtime_unavailable" | "run_not_found" | "invalid_run_id";
+    readonly name = "RuntimeError";
+    constructor(code: "member_busy" | "runtime_unavailable" | "run_not_found" | "invalid_run_id", message: string);
+}
+export type RunRecord = {
+    v: 1;
+    runId: string;
+    kind: RuntimeKind;
+    member: RuntimeMember;
+    run: RuntimeRun;
+    handle: RuntimeHandle;
+    startedAt: string;
+    endedAt?: string;
+    state: RunState;
+    exitCode?: number;
+    resultPath?: string;
+    detail?: string;
+};
+/** A normal adapter launch should have produced a durable reference well before this bound. */
+export declare const STARTING_RECONCILIATION_TIMEOUT_MS: number;
+export declare const runRecordSchema: z.ZodType<RunRecord>;
+export declare function runsDirectory(home: string): string;
+export declare function runRecordPath(home: string, runId: string): string;
+export declare function runLogPath(home: string, runId: string): string;
+export declare function runResultPath(home: string, runId: string): string;
+export declare function writeRunRecord(home: string, record: RunRecord): Promise<void>;
+export declare function readRunRecord(home: string, runId: string): Promise<RunRecord | undefined>;
+export declare function listRunRecords(home: string, filter?: {
+    swarm?: string;
+    account?: string;
+}): Promise<RunRecord[]>;
+export declare function refreshRunRecord(home: string, record: RunRecord, runtime?: Runtime, now?: () => Date): Promise<RunRecord>;
+export declare function startDetachedRun(args: {
+    home: string;
+    runtime: Runtime;
+    member: RuntimeMember;
+    run: RuntimeRun;
+    now?: () => Date;
+    /** Environment whose secret-named values are scrubbed from the stored task. */
+    env?: NodeJS.ProcessEnv;
+}): Promise<RunRecord>;
+/**
+ * Scrubs credentials from text that a detached run stores (registry task, result file, log).
+ * It removes the values of secret-named environment variables and structurally recognisable
+ * secrets (private keys, vAPI API keys, bearer tokens, recovery phrases), and nothing else, so
+ * ordinary words and result fields stay intact.
+ */
+export declare function redactRunText(value: string, env?: NodeJS.ProcessEnv): string;
+/** Applies {@link redactRunText} to every string value; object keys and other values are kept. */
+export declare function redactRunValue<T>(value: T, env?: NodeJS.ProcessEnv): T;
+export declare function stopRun(args: {
+    home: string;
+    runtime: Runtime;
+    record: RunRecord;
+    now?: () => Date;
+    confirmWorkerStopped?: boolean;
+}): Promise<RunRecord>;
+export type DetachedRunSummary = {
+    member: string;
+    role?: string;
+    swarm?: string;
+    runId: string;
+    kind: RuntimeKind;
+    mode: "agent" | "lead";
+    state: RunState;
+    startedAt: string;
+    endedAt?: string;
+    exitCode?: number;
+    parentRunId?: string;
+    detail?: string;
+};
+export type DetachedSwarmRunResult = {
+    detached: true;
+    runId: string;
+    mode: "lead" | "each";
+    kind: RuntimeKind;
+    runs: DetachedRunSummary[];
+    skipped: Array<{
+        member: string;
+        role: string;
+        reason: string;
+    }>;
+};
+export declare function summarizeRunRecord(record: RunRecord): DetachedRunSummary;
+export declare function startDetachedSwarmRun(input: {
+    name: string;
+    task: string;
+    mode: "lead" | "each";
+    lead?: string;
+    budgetUsd?: string;
+    drawUsd?: string;
+}, deps: {
+    home: string;
+    store: WalletStore;
+    runtime: Runtime;
+    readProfile?: (account: string) => Promise<AgentProfile | undefined>;
+    newRunId?: () => string;
+    now?: () => Date;
+    ledgerPath?: string;
+    env?: NodeJS.ProcessEnv;
+}): Promise<DetachedSwarmRunResult>;

package/dist/agent/swarm-run.d.ts

@@ -0,0 +1,94 @@
+import { type AgentProfile, type RunBudget, type SwarmCapitalDeps, type SwarmFile, type SwarmStatusResult, type WalletStore } from "@vapi-network/core";
+import { runAgent, type RunAgentDeps } from "./run.js";
+export type SwarmRunMode = "lead" | "each";
+export type RunSwarmOptions = {
+    name: string;
+    task: string;
+    mode: SwarmRunMode;
+    lead?: string;
+    budgetUsd?: string;
+    drawUsd?: string;
+    concurrency?: number;
+    runId?: string;
+};
+export type SwarmRunInput = Omit<RunSwarmOptions, "mode" | "concurrency" | "runId"> & {
+    mode?: SwarmRunMode;
+};
+export type SwarmMemberTarget = {
+    account: string;
+    role: string;
+    profile: AgentProfile;
+};
+export type MemberRunOptions = {
+    runId: string;
+    budget: RunBudget;
+    runMeta: {
+        swarm: string;
+        member: string;
+        parentRunId?: string;
+    };
+    profile: AgentProfile;
+    approvals: "tty" | "decline";
+};
+export type RunSwarmDeps = {
+    home: string;
+    store: WalletStore;
+    capital: SwarmCapitalDeps;
+    depsForMember(member: SwarmMemberTarget, runOpts: MemberRunOptions): Promise<RunAgentDeps>;
+    status(name: string): Promise<SwarmStatusResult>;
+    readProfile?: (account: string) => Promise<AgentProfile | undefined>;
+    runAgent?: typeof runAgent;
+    newRunId?: () => string;
+    ledgerPath?: string;
+    now?: () => Date;
+};
+export type SwarmRunMemberResult = {
+    member: string;
+    role: string;
+    runId: string | null;
+    parentRunId?: string;
+    answer: string | null;
+    stoppedBecause: {
+        reason: string;
+        detail?: string;
+    } | null;
+    spentUsd: number | null;
+    budgetUsd: number;
+    status: "finished" | "stopped" | "error" | "skipped";
+    reason?: string;
+};
+export type SwarmRunResult = {
+    runId: string;
+    mode: SwarmRunMode;
+    members: SwarmRunMemberResult[];
+    drawUsedUsd: number;
+    drawLimitUsd: number;
+    net: Array<{
+        member: string;
+        balanceUsd: string;
+        allocatedInUsd: string;
+        sweptOutUsd: string;
+        netUsd: string;
+    }>;
+    netError?: string;
+};
+export declare class SwarmRunError extends Error {
+    readonly code: "no_lead" | "invalid_lead" | "invalid_amount" | "no_eligible_members";
+    readonly name = "SwarmRunError";
+    constructor(code: "no_lead" | "invalid_lead" | "invalid_amount" | "no_eligible_members", message: string);
+}
+export type MemberAssessment = {
+    account: string;
+    role: string;
+    eligible: true;
+    target: SwarmMemberTarget;
+} | {
+    account: string;
+    role: string;
+    eligible: false;
+    reason: "not_linked" | "no_profile" | "paused";
+};
+export declare function runSwarm(opts: RunSwarmOptions, deps: RunSwarmDeps): Promise<SwarmRunResult>;
+export declare function assessSwarmMembers(swarm: SwarmFile, deps: Pick<RunSwarmDeps, "home" | "store" | "readProfile">): Promise<MemberAssessment[]>;
+export declare function selectLead(opts: Pick<RunSwarmOptions, "name" | "lead">, assessments: readonly MemberAssessment[]): SwarmMemberTarget;
+export declare function memberBudgetAtomic(account: string, configured: bigint | undefined, deps: Pick<RunSwarmDeps, "home" | "store" | "ledgerPath" | "now">): Promise<bigint>;

package/dist/index.d.ts

@@ -4,11 +4,17 @@ export { resolveServiceEndpoint, resolveServiceListing, searchMarketplace, type
 export { getWallet, type WalletAddresses, type WalletBalance } from "./tools/wallet.js";
 export { WalletSession, type SessionWallet, type SessionWalletInfo, type WalletSessionOptions, } from "./wallet-session.js";
 export { buildSIWxProof, parseSIWxResponse } from "./siwx.js";
-export { UNTRUSTED_NOTICE, decidePayment, wrapUntrusted, type PayDecision, } from "./agent/guards.js";
+export { UNTRUSTED_NOTICE, decideFunding, decidePayment, decideRelease, wrapUntrusted, type FundingDecision, type PayDecision, type ReleaseDecision, } from "./agent/guards.js";
 export { createAgentRunDeps } from "./agent/deps.js";
-export { loopToolsForProfile, runAgent, type AgentEvent, type RunAgentDeps, type RunAgentResult, } from "./agent/run.js";
+export { assessSwarmMembers, memberBudgetAtomic, runSwarm, selectLead, SwarmRunError, type MemberAssessment, type MemberRunOptions, type RunSwarmDeps, type RunSwarmOptions, type SwarmMemberTarget, type SwarmRunInput, type SwarmRunMemberResult, type SwarmRunMode, type SwarmRunResult, } from "./agent/swarm-run.js";
+export { listRunRecords, readRunRecord, redactRunText, redactRunValue, refreshRunRecord, runLogPath, runRecordPath, runRecordSchema, runResultPath, runsDirectory, STARTING_RECONCILIATION_TIMEOUT_MS, RuntimeError, startDetachedRun, startDetachedSwarmRun, stopRun, summarizeRunRecord, writeRunRecord, type DetachedRunSummary, type DetachedSwarmRunResult, type RunRecord, type RunState, type Runtime, type RuntimeHandle, type RuntimeKind, type RuntimeMember, type RuntimeRun, type RuntimeStatus, } from "./agent/runtime.js";
+export { loopActionsFor, loopToolsForProfile, runAgent, type AgentEvent, type RunAgentDeps, type RunAgentResult, type SwarmRunContext, } from "./agent/run.js";
+export { accountsSend, accountsSendInputSchema, accountsSendOutputSchema, type AccountsSendInput, } from "./actions/accounts.js";
 export { callInspect, callInspectInputSchema, callPay, callPayInputSchema, callSearch, callSearchInputSchema, callToolResultSchema, createCallPort, inspectToolResultSchema, MAX_CACHED_MARKETPLACE_REFS, walletArgument, type CreateCallPortOptions, type PaymentResolution, } from "./actions/call.js";
-export { createRunState, inspectionCacheKey, type ActionContext, type ActionRunState, type ActionSurface, type CallPort, } from "./actions/context.js";
+export { callRead, callReadInputSchema, callReadOutputSchema, readPaidOrigin, type CallReadInput, type CallReadOutput, } from "./actions/call-read.js";
+export { createRunState, inspectionCacheKey, type AccountsPort, type ActionContext, type ActionRunState, type ActionSurface, type CallPort, type SwarmRunActionInput, type SwarmRunActionResult, type SwarmRunsInput, type SwarmRunsResult, type SwarmRunScope, } from "./actions/context.js";
 export { defineAction, toLoopName, type Action, type ActionGrant, type ActionMoney, } from "./actions/define.js";
 export { checkAction, exactUsdcPrice, type PolicyDecision } from "./actions/policy.js";
 export { ActionDeclinedError, actions, agentToolNames, findAction, registeredAgentProfileSchema, runAction, } from "./actions/register.js";
+export { attachedSwarmRunOutputSchema, detachedRunSummarySchema, detachedSwarmRunOutputSchema, swarmRun, swarmRunInputSchema, swarmRunOutputSchema, swarmRuns, swarmRunsInputSchema, swarmRunsOutputSchema, swarmAgentActions, type SwarmAllocateResult, type SwarmDelegateResult, } from "./actions/swarm-agent.js";
+export { createAccountsPort, type CreateAccountsPortOptions } from "./tools/accounts.js";