@paybond/kit 0.7.1 → 0.9.0

package/README.md

@@ -1,6 +1,6 @@
 # `@paybond/kit`
 
-Paybond Kit for TypeScript is the npm package for tenant-bound Paybond integrations. It opens hosted Gateway sessions, verifies capability tokens, signs intent and evidence payloads, uses Stripe Connect or x402 / USDC-on-Base settlement rails, and reads tenant-scoped Signal, fraud, ledger, protocol, and A2A data.
+Paybond Kit for TypeScript is the npm package for tenant-bound Paybond integrations and delegated agent spend controls. It opens hosted Gateway sessions, verifies capability tokens, authorizes tool-call spend, signs intent and evidence payloads, uses Stripe Connect or x402 / USDC-on-Base settlement rails, reads tenant-scoped Signal, fraud, ledger, protocol, and A2A data, and includes agent-runtime integrations.
 
 ## Install
 
@@ -59,6 +59,45 @@ try {
 }
 ```
 
+## Agent spend controls
+
+Use Paybond Kit when an agent workflow needs delegated spend guardrails, tool-call budget checks, paid API or vendor action approval, evidence, release/refund logic, disputes, or audit-ready receipts.
+
+```ts
+import { Paybond } from "@paybond/kit";
+
+const paybond = await Paybond.open({
+  apiKey: process.env.PAYBOND_API_KEY!,
+  expectedEnvironment: "sandbox",
+});
+
+const created = await paybond.intents.create({
+  // principal, payee, budget, predicate, evidence schema, deadline...
+  allowedTools: ["travel.book_hotel"],
+  settlementRail: "stripe_connect",
+});
+
+const intentId = String(created.intent_id);
+const capabilityToken = String(created.capability_token ?? "");
+if (!capabilityToken) {
+  throw new Error("fund the intent before guarding tools");
+}
+
+const guard = paybond.spendGuard(intentId, capabilityToken);
+const guardedTool = guard.guardTool(
+  { operation: "travel.book_hotel", requestedSpendCents: 20_000 },
+  async (input) => bookHotel(input),
+);
+```
+
+The `paybond.harbor` client is created by `Paybond.open(...)` and bound to the tenant resolved from the service-account API key. Normal integrations read `capability_token` from `paybond.intents.create(...)`, or from `paybond.intents.fund(...)` after an `x402_usdc_base` payment challenge is satisfied.
+
+Scaffold a wrapper:
+
+```bash
+npx -p @paybond/kit paybond-init --framework provider-agnostic --out paybond-spend-guard.ts
+```
+
 ## What the package includes
 
 Core SDK:
@@ -67,6 +106,9 @@ Core SDK:
 - `HarborClient` for capability verification, intent creation, x402 funding, evidence submission, and ledger reads
 - `paybond.signal` and `paybond.fraud` on `Paybond` sessions opened from one service-account API key
 - `PaybondIntents` helpers for principal-signed intent creation, x402 funding, and payee-signed evidence submission
+- `PaybondSpendGuard`, `authorizeSpend`, and `guardTool` for spend-named wrappers around capability verification
+- Runtime-neutral and framework aliases: `paybondAgentToolSpendGuard`, `paybondRuntimeNeutralToolSpendGuard`, `paybondLangGraphToolSpendGuard`, and `paybondMCPToolSpendGuard`
+- `paybondRuntimeToolCallAdapter` for agent SDKs and custom runtimes that expose a tool-call object plus an application-owned executor
 
 Gateway and trust helpers:
 
@@ -74,6 +116,7 @@ Gateway and trust helpers:
 - `GatewayFraudClient` and `ServiceAccountFraudSession` for tenant-scoped fraud assessments, review queues, review events, metrics, and release-gate config
 - Protocol-v2 helpers for mandate verification, replay-safe recognition proof verification, receipt reads, and A2A discovery
 - `paybond-mcp-server` for tenant-bound MCP tool exposure to any MCP-compatible host
+- `paybond-init` for generating a small spend guard wrapper
 
 Agent-facing surfaces are model-provider agnostic. Paybond verifies tool operations and tenant scope, not whether a tool call came from OpenAI, Anthropic, Gemini, a local model, or another runtime.
 
@@ -92,7 +135,7 @@ Gateway-backed protocol helpers throw `ProtocolHttpError` with parsed `errorCode
 ## What it does not include
 
 - No operator-tier settlement or console workflows
-- No model-provider-specific TypeScript agent wrapper; use the documented app-side wrapper pattern with `PaybondCapabilityBinding`
+- No model-provider-specific TypeScript agent wrapper; use the documented app-side wrapper pattern with `paybond.spendGuard(...)`
 - No model-provider-specific MCP wrapper; the MCP server is host-agnostic and works with any MCP-compatible runtime
 
 ## Docs

package/dist/index.d.ts

@@ -652,7 +652,52 @@ export declare class PaybondCapabilityBinding {
     readonly intentId: string;
     readonly capabilityToken: string;
     constructor(harbor: Pick<HarborClient | GatewayHarborClient, "tenantId" | "verifyCapability">, intentId: string, capabilityToken: string);
+    verifySpendCapability(input: PaybondSpendAuthorizationInput): Promise<VerifyCapabilityResult>;
+    authorizeSpend(input: PaybondSpendAuthorizationInput): Promise<VerifyCapabilityResult>;
 }
+export type PaybondSpendGuardInit = {
+    harbor: Pick<HarborClient | GatewayHarborClient, "tenantId" | "verifyCapability">;
+    intentId: string;
+    capabilityToken: string;
+};
+export type PaybondSpendAuthorizationInput = {
+    operation: string;
+    requestedSpendCents?: number;
+};
+export declare class PaybondSpendDeniedError extends Error {
+    readonly result: VerifyCapabilityResult;
+    constructor(result: VerifyCapabilityResult);
+}
+export type PaybondToolHandler<TArgs extends unknown[], TResult> = (...args: TArgs) => TResult | Promise<TResult>;
+export type PaybondGuardedToolHandler<TArgs extends unknown[], TResult> = (...args: TArgs) => Promise<Awaited<TResult>>;
+export declare class PaybondSpendGuard {
+    readonly harbor: Pick<HarborClient | GatewayHarborClient, "tenantId" | "verifyCapability">;
+    readonly intentId: string;
+    readonly capabilityToken: string;
+    constructor(init: PaybondSpendGuardInit | PaybondCapabilityBinding);
+    verifySpendCapability(input: PaybondSpendAuthorizationInput): Promise<VerifyCapabilityResult>;
+    authorizeSpend(input: PaybondSpendAuthorizationInput): Promise<VerifyCapabilityResult>;
+    assertSpendAuthorized(input: PaybondSpendAuthorizationInput): Promise<VerifyCapabilityResult>;
+    guardTool<TArgs extends unknown[], TResult>(input: PaybondSpendAuthorizationInput, handler: PaybondToolHandler<TArgs, TResult>): PaybondGuardedToolHandler<TArgs, TResult>;
+}
+export declare function authorizeSpend(source: PaybondSpendGuardInit | PaybondCapabilityBinding, input: PaybondSpendAuthorizationInput): Promise<VerifyCapabilityResult>;
+export declare function guardTool<TArgs extends unknown[], TResult>(source: PaybondSpendGuardInit | PaybondCapabilityBinding, input: PaybondSpendAuthorizationInput, handler: PaybondToolHandler<TArgs, TResult>): PaybondGuardedToolHandler<TArgs, TResult>;
+export declare const paybondAgentToolSpendGuard: typeof guardTool;
+export declare const paybondRuntimeNeutralToolSpendGuard: typeof guardTool;
+export declare const paybondLangGraphToolSpendGuard: typeof guardTool;
+export declare const paybondMCPToolSpendGuard: typeof guardTool;
+export type PaybondRuntimeOperation<TCall> = string | ((call: TCall) => string);
+export type PaybondRuntimeSpendCents<TCall> = number | ((call: TCall) => number | undefined);
+export type PaybondRuntimeToolExecutor<TCall, TResult> = (call: TCall) => TResult | Promise<TResult>;
+export type PaybondRuntimeDenyHandler<TCall, TResult> = (result: VerifyCapabilityResult, call: TCall) => TResult | Promise<TResult>;
+export type PaybondRuntimeToolCallAdapterInit<TCall, TResult> = {
+    source: PaybondSpendGuardInit | PaybondCapabilityBinding;
+    operation: PaybondRuntimeOperation<TCall>;
+    execute: PaybondRuntimeToolExecutor<TCall, TResult>;
+    requestedSpendCents?: PaybondRuntimeSpendCents<TCall>;
+    onDeny?: PaybondRuntimeDenyHandler<TCall, TResult>;
+};
+export declare function paybondRuntimeToolCallAdapter<TCall, TResult>(init: PaybondRuntimeToolCallAdapterInit<TCall, TResult>): (call: TCall) => Promise<Awaited<TResult>>;
 export type PaybondOpenOptions = {
     apiKey: string;
     gatewayBaseUrl?: string;
@@ -701,6 +746,18 @@ export declare class HarborClient {
         operation: string;
         requestedSpendCents?: number;
     }): Promise<VerifyCapabilityResult>;
+    verifySpendCapability(input: {
+        intentId: string;
+        token: string;
+        operation: string;
+        requestedSpendCents?: number;
+    }): Promise<VerifyCapabilityResult>;
+    authorizeSpend(input: {
+        intentId: string;
+        token: string;
+        operation: string;
+        requestedSpendCents?: number;
+    }): Promise<VerifyCapabilityResult>;
     /**
      * POST `/intents` with a principal-signed `CreateIntentRequest` JSON body.
      *
@@ -787,6 +844,18 @@ export declare class GatewayHarborClient {
         operation: string;
         requestedSpendCents?: number;
     }): Promise<VerifyCapabilityResult>;
+    verifySpendCapability(input: {
+        intentId: string;
+        token: string;
+        operation: string;
+        requestedSpendCents?: number;
+    }): Promise<VerifyCapabilityResult>;
+    authorizeSpend(input: {
+        intentId: string;
+        token: string;
+        operation: string;
+        requestedSpendCents?: number;
+    }): Promise<VerifyCapabilityResult>;
     createIntent(body: Record<string, unknown>, options: GatewayHarborMutationOptions): Promise<Record<string, unknown>>;
     fundIntent(intentId: string, options: GatewayHarborMutationOptions & {
         paymentSignature?: string;
@@ -962,6 +1031,9 @@ export declare class PaybondIntents {
     create(params: PaybondCreateIntentParams & {
         idempotencyKey?: string;
     }): Promise<Record<string, unknown>>;
+    createSpendIntent(params: PaybondCreateIntentParams & {
+        idempotencyKey?: string;
+    }): Promise<Record<string, unknown>>;
     /**
      * Advance Harbor `/intents/{id}/fund` for x402 / USDC-on-Base intents.
      */
@@ -993,6 +1065,13 @@ export declare class Paybond {
     static open(init: PaybondOpenOptions): Promise<Paybond>;
     /** Reserved for future HTTP client cleanup; safe to call after work completes. */
     aclose(): Promise<void>;
+    spendGuard(intentId: string, capabilityToken: string): PaybondSpendGuard;
+    authorizeSpend(input: {
+        intentId: string;
+        token: string;
+        operation: string;
+        requestedSpendCents?: number;
+    }): Promise<VerifyCapabilityResult>;
 }
 export { normalizeJson, jsonValueDigest } from "./json-digest.js";
 export { buildSignedCreateIntentBody, intentCreationSignBytesRaw, type BuildSignedCreateIntentParams, type SettlementRail, } from "./principal-intent.js";

package/dist/index.js

@@ -156,6 +156,99 @@ export class PaybondCapabilityBinding {
         this.intentId = intentId;
         this.capabilityToken = capabilityToken;
     }
+    async verifySpendCapability(input) {
+        return this.harbor.verifyCapability({
+            intentId: this.intentId,
+            token: this.capabilityToken,
+            operation: input.operation,
+            requestedSpendCents: input.requestedSpendCents,
+        });
+    }
+    async authorizeSpend(input) {
+        return this.verifySpendCapability(input);
+    }
+}
+export class PaybondSpendDeniedError extends Error {
+    result;
+    constructor(result) {
+        const reason = result.message ?? result.code ?? "denied";
+        super(`Paybond spend authorization denied: ${reason}`);
+        this.name = "PaybondSpendDeniedError";
+        this.result = result;
+    }
+}
+export class PaybondSpendGuard {
+    harbor;
+    intentId;
+    capabilityToken;
+    constructor(init) {
+        this.harbor = init.harbor;
+        this.intentId = init.intentId;
+        this.capabilityToken = init.capabilityToken;
+    }
+    async verifySpendCapability(input) {
+        return this.harbor.verifyCapability({
+            intentId: this.intentId,
+            token: this.capabilityToken,
+            operation: input.operation,
+            requestedSpendCents: input.requestedSpendCents,
+        });
+    }
+    async authorizeSpend(input) {
+        return this.verifySpendCapability(input);
+    }
+    async assertSpendAuthorized(input) {
+        const result = await this.authorizeSpend(input);
+        if (!result.allow) {
+            throw new PaybondSpendDeniedError(result);
+        }
+        return result;
+    }
+    guardTool(input, handler) {
+        return async (...args) => {
+            await this.assertSpendAuthorized(input);
+            return await handler(...args);
+        };
+    }
+}
+export async function authorizeSpend(source, input) {
+    return new PaybondSpendGuard(source).authorizeSpend(input);
+}
+export function guardTool(source, input, handler) {
+    return new PaybondSpendGuard(source).guardTool(input, handler);
+}
+export const paybondAgentToolSpendGuard = guardTool;
+export const paybondRuntimeNeutralToolSpendGuard = guardTool;
+export const paybondLangGraphToolSpendGuard = guardTool;
+export const paybondMCPToolSpendGuard = guardTool;
+function resolveRuntimeOperation(operation, call) {
+    const value = typeof operation === "function" ? operation(call) : operation;
+    const trimmed = String(value).trim();
+    if (!trimmed) {
+        throw new Error("Paybond operation must be a non-empty string");
+    }
+    return trimmed;
+}
+function resolveRuntimeSpendCents(requestedSpendCents, call) {
+    if (requestedSpendCents === undefined) {
+        return undefined;
+    }
+    return typeof requestedSpendCents === "function" ? requestedSpendCents(call) : requestedSpendCents;
+}
+export function paybondRuntimeToolCallAdapter(init) {
+    const guard = new PaybondSpendGuard(init.source);
+    return async (call) => {
+        const operation = resolveRuntimeOperation(init.operation, call);
+        const requestedSpendCents = resolveRuntimeSpendCents(init.requestedSpendCents, call);
+        const result = await guard.authorizeSpend({ operation, requestedSpendCents });
+        if (!result.allow) {
+            if (init.onDeny) {
+                return await init.onDeny(result, call);
+            }
+            throw new PaybondSpendDeniedError(result);
+        }
+        return await init.execute(call);
+    };
 }
 /**
  * HTTP client for Harbor: capability verify, intents, evidence, and tenant-scoped ledger reads
@@ -329,6 +422,12 @@ export class HarborClient {
             message: body.message,
         };
     }
+    async verifySpendCapability(input) {
+        return this.verifyCapability(input);
+    }
+    async authorizeSpend(input) {
+        return this.verifyCapability(input);
+    }
     /**
      * POST `/intents` with a principal-signed `CreateIntentRequest` JSON body.
      *
@@ -653,6 +752,12 @@ export class GatewayHarborClient {
             message: body.message,
         };
     }
+    async verifySpendCapability(input) {
+        return this.verifyCapability(input);
+    }
+    async authorizeSpend(input) {
+        return this.verifyCapability(input);
+    }
     async createIntent(body, options) {
         const { res, text, url } = await this.postJSON("/harbor/intents", body, this.mutationHeaders("createIntent", options));
         if (!res.ok) {
@@ -1642,6 +1747,9 @@ export class PaybondIntents {
         });
         return this.harbor.createIntent(body, { idempotencyKey, recognitionProof });
     }
+    async createSpendIntent(params) {
+        return this.create(params);
+    }
     /**
      * Advance Harbor `/intents/{id}/fund` for x402 / USDC-on-Base intents.
      */
@@ -1715,6 +1823,12 @@ export class Paybond {
     async aclose() {
         await Promise.resolve();
     }
+    spendGuard(intentId, capabilityToken) {
+        return new PaybondSpendGuard({ harbor: this.harbor, intentId, capabilityToken });
+    }
+    async authorizeSpend(input) {
+        return this.harbor.authorizeSpend(input);
+    }
 }
 export { normalizeJson, jsonValueDigest } from "./json-digest.js";
 export { buildSignedCreateIntentBody, intentCreationSignBytesRaw, } from "./principal-intent.js";

package/dist/init.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(argv?: string[]): Promise<number>;

package/dist/init.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+const FRAMEWORKS = new Set([
+    "generic",
+    "provider-agnostic",
+    "openai",
+    "claude",
+    "anthropic",
+    "gemini",
+    "google-ai",
+    "vercel-ai",
+    "langgraph",
+    "mcp",
+]);
+const FRAMEWORK_NOTES = {
+    generic: "Wrap the returned function around any side-effecting tool handler.",
+    "provider-agnostic": "Use the guarded handler with OpenAI, Gemini, Claude/Anthropic, local models, or any custom runtime.",
+    openai: "Call the guarded handler before the OpenAI tool call performs paid or external work.",
+    claude: "Call the guarded handler before the Claude tool-use action performs paid or external work.",
+    anthropic: "Call the guarded handler before the Anthropic tool-use action performs paid or external work.",
+    gemini: "Call the guarded handler before the Gemini function call performs paid or external work.",
+    "google-ai": "Call the guarded handler before the Google AI function call performs paid or external work.",
+    "vercel-ai": "Call the guarded handler from your Vercel AI SDK tool execute function.",
+    langgraph: "Call the guarded handler from the LangGraph JS node or tool wrapper that performs paid work.",
+    mcp: "Call the guarded handler inside the MCP tool implementation before paid or external work runs.",
+};
+function usage() {
+    return [
+        "Usage: paybond-init [--framework generic|provider-agnostic|openai|claude|anthropic|gemini|google-ai|vercel-ai|langgraph|mcp] [--out paybond-spend-guard.ts] [--force]",
+        "",
+        "Scaffolds a Paybond spend guard wrapper for delegated agent spend controls.",
+    ].join("\n");
+}
+function parseArgs(argv) {
+    let framework = "generic";
+    let out = "paybond-spend-guard.ts";
+    let force = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--help" || arg === "-h") {
+            process.stdout.write(`${usage()}\n`);
+            process.exitCode = 0;
+            return { framework, out, force };
+        }
+        if (arg === "--force") {
+            force = true;
+            continue;
+        }
+        if (arg === "--framework") {
+            const raw = argv[i + 1];
+            i += 1;
+            if (!raw || !FRAMEWORKS.has(raw)) {
+                throw new Error("invalid --framework");
+            }
+            framework = raw;
+            continue;
+        }
+        if (arg === "--out") {
+            const raw = argv[i + 1];
+            i += 1;
+            if (!raw || raw.startsWith("-")) {
+                throw new Error("invalid --out");
+            }
+            out = raw;
+            continue;
+        }
+        throw new Error(`unknown argument: ${arg}`);
+    }
+    return { framework, out, force };
+}
+function template(framework) {
+    return `import { Paybond, type FundIntentResult } from "@paybond/kit";
+
+type ToolInput = {
+  city: string;
+  maxPriceCents: number;
+};
+
+type FundedIntent = {
+  intentId: string;
+  capabilityToken: string;
+};
+
+export async function openPaybond(): Promise<Paybond> {
+  return Paybond.open({
+    apiKey: process.env.PAYBOND_API_KEY!,
+    expectedEnvironment: "sandbox",
+  });
+}
+
+export function fundedIntentFromCreate(created: Record<string, unknown>): FundedIntent {
+  const intentId = String(created["intent_id"] ?? "");
+  const capabilityToken = String(created["capability_token"] ?? "");
+  if (!intentId) {
+    throw new Error("intent create response missing intent_id");
+  }
+  if (!capabilityToken) {
+    throw new Error("intent is not funded yet; call paybond.intents.fund(...) before guarding tools");
+  }
+  return { intentId, capabilityToken };
+}
+
+export function fundedIntentFromFund(funded: FundIntentResult): FundedIntent {
+  if (!funded.capabilityToken) {
+    throw new Error("intent funding did not return a capabilityToken yet");
+  }
+  return { intentId: funded.intentId, capabilityToken: funded.capabilityToken };
+}
+
+async function bookHotel(input: ToolInput): Promise<{ confirmation: string }> {
+  // Put the side-effecting tool call here.
+  return { confirmation: \`demo-\${input.city}-\${input.maxPriceCents}\` };
+}
+
+export async function buildGuardedHotelTool(params: {
+  paybond: Paybond;
+  intentId: string;
+  capabilityToken: string;
+}): Promise<(input: ToolInput) => Promise<{ confirmation: string }>> {
+  if (!params.capabilityToken.trim()) {
+    throw new Error("fund the intent before guarding tools");
+  }
+  const guard = params.paybond.spendGuard(params.intentId, params.capabilityToken);
+
+  // ${FRAMEWORK_NOTES[framework]}
+  return guard.guardTool(
+    {
+      operation: "travel.book_hotel",
+      requestedSpendCents: 20_000,
+    },
+    bookHotel,
+  );
+}
+`;
+}
+async function writeScaffold(out, body, force) {
+    // @ts-expect-error Node builtins are available in the published CLI runtime.
+    const fs = await import("node:fs/promises");
+    try {
+        await fs.stat(out);
+        if (!force) {
+            throw new Error(`${out} already exists; pass --force to overwrite`);
+        }
+    }
+    catch (err) {
+        if (!(err && typeof err === "object" && "code" in err && err.code === "ENOENT")) {
+            if (!force) {
+                throw err;
+            }
+        }
+    }
+    await fs.writeFile(out, body, "utf8");
+}
+export async function main(argv = process.argv.slice(2)) {
+    let parsed;
+    try {
+        parsed = parseArgs(argv);
+    }
+    catch (err) {
+        process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n\n${usage()}\n`);
+        return 1;
+    }
+    if (argv.includes("--help") || argv.includes("-h")) {
+        return 0;
+    }
+    await writeScaffold(parsed.out, template(parsed.framework), parsed.force);
+    process.stdout.write(`Created ${parsed.out}\n`);
+    return 0;
+}
+main().then((code) => {
+    process.exitCode = code;
+}, (err) => {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+    process.exitCode = 1;
+});

package/dist/mcp-server.js

@@ -364,6 +364,8 @@ export class PaybondMCPServer {
                             version: SERVER_VERSION,
                         },
                         instructions: "This MCP server is tenant-bound to the configured Paybond service-account API key. " +
+                            "Use paybond_create_spend_intent or paybond_fund_intent to obtain the intent_id and " +
+                            "capability_token, then call paybond_authorize_agent_spend before side-effecting tools. " +
                             "It works with any MCP-compatible host and does not assume a specific model provider.",
                     },
                 };
@@ -447,10 +449,37 @@ export class PaybondMCPServer {
             },
             {
                 name: "paybond_verify_capability",
-                description: "Verify a capability token for one tenant-bound Harbor intent through the gateway compatibility route.",
+                description: "Verify a capability token returned by a created or funded Paybond intent for one tenant-bound Harbor intent.",
                 inputSchema: objectSchema({
                     intent_id: { type: "string", description: "Canonical Harbor intent UUID." },
-                    token: { type: "string", description: "Capability token to verify." },
+                    token: {
+                        type: "string",
+                        description: "Capability token returned by paybond_create_spend_intent or paybond_fund_intent.",
+                    },
+                    operation: { type: "string", description: "Delegated operation or tool name." },
+                    requested_spend_cents: {
+                        type: "integer",
+                        description: "Optional requested spend in cents for this tool call.",
+                    },
+                }, ["intent_id", "token", "operation"]),
+                call: async (args) => this.runtime.verifyCapability({
+                    intentId: uuidArg(args.intent_id, "intent_id"),
+                    token: stringArg(args.token, "token"),
+                    operation: stringArg(args.operation, "operation"),
+                    requestedSpendCents: args.requested_spend_cents === undefined
+                        ? 0
+                        : intArg(args.requested_spend_cents, "requested_spend_cents"),
+                }),
+            },
+            {
+                name: "paybond_authorize_agent_spend",
+                description: "Provider-agnostic spend gate: verify the funded intent's capability token before a side-effecting tool, paid API, vendor action, or settlement workflow executes.",
+                inputSchema: objectSchema({
+                    intent_id: { type: "string", description: "Canonical Harbor intent UUID." },
+                    token: {
+                        type: "string",
+                        description: "Capability token returned by paybond_create_spend_intent or paybond_fund_intent.",
+                    },
                     operation: { type: "string", description: "Delegated operation or tool name." },
                     requested_spend_cents: {
                         type: "integer",
@@ -630,9 +659,23 @@ export class PaybondMCPServer {
                     idempotencyKey: optionalString(args.idempotency_key),
                 }),
             },
+            {
+                name: "paybond_create_spend_intent",
+                description: "Create a signed Paybond spend intent through the gateway /harbor route. Use this when an agent workflow needs bounded budget, allowed operations, evidence, and settlement review. If the selected rail funds immediately, use the returned intent_id and capability_token with paybond_authorize_agent_spend.",
+                inputSchema: objectSchema({
+                    body: { type: "object", additionalProperties: true },
+                    recognition_proof: { type: "object", additionalProperties: true },
+                    idempotency_key: { type: "string" },
+                }, ["body", "recognition_proof"]),
+                call: async (args) => this.runtime.createHarborIntent({
+                    body: ensureObject(args.body, "body"),
+                    recognitionProof: ensureObject(args.recognition_proof, "recognition_proof"),
+                    idempotencyKey: optionalString(args.idempotency_key),
+                }),
+            },
             {
                 name: "paybond_fund_intent",
-                description: "Advance Harbor funding through the gateway /harbor path with a replay-safe recognition proof.",
+                description: "Advance Harbor funding through the gateway /harbor path with a replay-safe recognition proof. When funding succeeds, use the returned capability_token with intent_id in paybond_authorize_agent_spend.",
                 inputSchema: objectSchema({
                     intent_id: { type: "string" },
                     recognition_proof: { type: "object", additionalProperties: true },
@@ -662,6 +705,22 @@ export class PaybondMCPServer {
                     idempotencyKey: optionalString(args.idempotency_key),
                 }),
             },
+            {
+                name: "paybond_submit_spend_evidence",
+                description: "Submit signed evidence for a Paybond spend intent so release, refund, review, and receipt generation use the same audit-ready record.",
+                inputSchema: objectSchema({
+                    intent_id: { type: "string" },
+                    body: { type: "object", additionalProperties: true },
+                    recognition_proof: { type: "object", additionalProperties: true },
+                    idempotency_key: { type: "string" },
+                }, ["intent_id", "body", "recognition_proof"]),
+                call: async (args) => this.runtime.submitHarborEvidence({
+                    intentId: uuidArg(args.intent_id, "intent_id"),
+                    body: ensureObject(args.body, "body"),
+                    recognitionProof: ensureObject(args.recognition_proof, "recognition_proof"),
+                    idempotencyKey: optionalString(args.idempotency_key),
+                }),
+            },
             {
                 name: "paybond_confirm_settlement",
                 description: "Confirm Harbor settlement through the gateway /harbor path with a replay-safe recognition proof.",

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@paybond/kit",
-  "version": "0.7.1",
-  "description": "Paybond Kit for TypeScript: hosted Gateway sessions, capability verification, signed intent/evidence flows, and Stripe Connect or x402 / USDC-on-Base settlement.",
+  "version": "0.9.0",
+  "description": "Paybond Kit for TypeScript: agent spend controls, hosted Gateway sessions, capability verification, signed intent/evidence flows, and Stripe Connect or x402 / USDC-on-Base settlement.",
   "license": "Apache-2.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
+    "paybond-init": "dist/init.js",
     "paybond-mcp-server": "dist/mcp-server.js"
   },
   "exports": {
@@ -41,6 +42,14 @@
     "kit",
     "agents",
     "agent-runtime",
+    "agent-spend-controls",
+    "ai-agent-budget",
+    "delegated-spend",
+    "spend-guardrails",
+    "tool-call-spend-limits",
+    "gemini",
+    "claude",
+    "anthropic",
     "agent-payments",
     "escrow",
     "intent-escrow",