@paybond/kit 0.10.0 → 0.11.0

package/dist/agent-recognition.d.ts

@@ -0,0 +1,72 @@
+export type SignedAgentRecognitionProofV1 = {
+    schema_version: number;
+    kind: string;
+    key_id: string;
+    signature_algorithm: string;
+    issued_at: string;
+    expires_at: string;
+    nonce: string;
+    purpose: string;
+    verifier_context: {
+        tenant_id: string;
+        verifier_id: string;
+    };
+    request_envelope: {
+        method: string;
+        path: string;
+        body_digest_sha256_hex: string;
+    };
+    message_digest_sha256_hex: string;
+    signing_public_key_ed25519_hex: string;
+    ed25519_signature_hex: string;
+};
+export declare const AGENT_RECOGNITION_PROOF_SCHEMA_VERSION = 1;
+export declare const AGENT_RECOGNITION_PROOF_KIND_V1 = "paybond.agent_recognition_proof_v1";
+export declare const AGENT_RECOGNITION_SIGNATURE_ALGORITHM_ED25519 = "ed25519-sha256-json-v1";
+export declare const AGENT_RECOGNITION_GATEWAY_VERIFIER_ID = "paybond-gateway";
+export declare const AGENT_RECOGNITION_PURPOSE_EVIDENCE_SUBMIT = "harbor.intent.evidence.submit";
+export declare const AGENT_RECOGNITION_MAX_FRESHNESS_MS: number;
+export type SignAgentRecognitionProofV1Params = {
+    keyId: string;
+    purpose: string;
+    tenantId: string;
+    verifierId?: string;
+    method: string;
+    path: string;
+    body: Uint8Array | Record<string, unknown>;
+    issuedAt?: Date;
+    expiresAt?: Date;
+    nonce?: string;
+};
+type CanonicalRecognitionProof = {
+    schemaVersion: number;
+    kind: string;
+    keyId: string;
+    signatureAlgorithm: string;
+    issuedAt: string;
+    expiresAt: string;
+    nonce: string;
+    purpose: string;
+    verifierContext: {
+        tenantId: string;
+        verifierId: string;
+    };
+    requestEnvelope: {
+        method: string;
+        path: string;
+        bodyDigestSha256Hex: string;
+    };
+};
+/** Canonicalize request metadata that recognition proofs bind to. */
+export declare function newAgentRecognitionRequestEnvelope(method: string, path: string, body: Uint8Array | Record<string, unknown>): CanonicalRecognitionProof["requestEnvelope"];
+/** Validate, canonicalize, and sign a replay-safe `AgentRecognitionProofV1`. */
+export declare function signAgentRecognitionProofV1(signingSeed: Uint8Array, params: SignAgentRecognitionProofV1Params): SignedAgentRecognitionProofV1;
+/** Build a recognition proof for Gateway `POST /harbor/intents/{intentId}/evidence`. */
+export declare function signHarborEvidenceSubmitRecognitionProof(input: {
+    tenantId: string;
+    intentId: string;
+    evidenceBody: Record<string, unknown>;
+    keyId: string;
+    signingSeed: Uint8Array;
+}): SignedAgentRecognitionProofV1;
+export {};

package/dist/agent-recognition.js

@@ -0,0 +1,165 @@
+import { createHash, randomUUID } from "node:crypto";
+import { sign, getPublicKey } from "@noble/ed25519";
+import { ensureEd25519Sha512Sync } from "./ed25519-sync.js";
+export const AGENT_RECOGNITION_PROOF_SCHEMA_VERSION = 1;
+export const AGENT_RECOGNITION_PROOF_KIND_V1 = "paybond.agent_recognition_proof_v1";
+export const AGENT_RECOGNITION_SIGNATURE_ALGORITHM_ED25519 = "ed25519-sha256-json-v1";
+export const AGENT_RECOGNITION_GATEWAY_VERIFIER_ID = "paybond-gateway";
+export const AGENT_RECOGNITION_PURPOSE_EVIDENCE_SUBMIT = "harbor.intent.evidence.submit";
+export const AGENT_RECOGNITION_MAX_FRESHNESS_MS = 10 * 60 * 1000;
+const SCOPE_TOKEN_RE = /^[a-z0-9][a-z0-9._:/-]{0,127}$/;
+const HEX64_RE = /^[0-9a-f]{64}$/;
+function bytesToHex(bytes) {
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function sha256Hex(data) {
+    return createHash("sha256").update(data).digest("hex");
+}
+function formatRfc3339Seconds(date) {
+    return date.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function normalizeScopeToken(value, field) {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized) {
+        throw new Error(`agent recognition proof: ${field} is required`);
+    }
+    if (!SCOPE_TOKEN_RE.test(normalized)) {
+        throw new Error(`agent recognition proof: ${field} ${JSON.stringify(normalized)} is not canonical`);
+    }
+    return normalized;
+}
+function requestBodyBytes(body) {
+    if (body instanceof Uint8Array) {
+        return body;
+    }
+    return new TextEncoder().encode(JSON.stringify(body));
+}
+/** Canonicalize request metadata that recognition proofs bind to. */
+export function newAgentRecognitionRequestEnvelope(method, path, body) {
+    const normalizedMethod = method.trim().toUpperCase();
+    const normalizedPath = path.trim() || "/";
+    if (!normalizedMethod) {
+        throw new Error("agent recognition proof: request_envelope.method is required");
+    }
+    if (!normalizedPath.startsWith("/")) {
+        throw new Error('agent recognition proof: request_envelope.path must begin with "/"');
+    }
+    return {
+        method: normalizedMethod,
+        path: normalizedPath,
+        bodyDigestSha256Hex: sha256Hex(requestBodyBytes(body)),
+    };
+}
+function marshalCanonicalAgentRecognitionProof(proof) {
+    const payload = {
+        schema_version: proof.schemaVersion,
+        kind: proof.kind,
+        key_id: proof.keyId,
+        signature_algorithm: proof.signatureAlgorithm,
+        issued_at: proof.issuedAt,
+        expires_at: proof.expiresAt,
+        nonce: proof.nonce,
+        purpose: proof.purpose,
+        verifier_context: {
+            tenant_id: proof.verifierContext.tenantId,
+            verifier_id: proof.verifierContext.verifierId,
+        },
+        request_envelope: {
+            method: proof.requestEnvelope.method,
+            path: proof.requestEnvelope.path,
+            body_digest_sha256_hex: proof.requestEnvelope.bodyDigestSha256Hex,
+        },
+    };
+    return new TextEncoder().encode(JSON.stringify(payload));
+}
+function normalizeRecognitionProof(params) {
+    const tenantId = params.tenantId.trim();
+    if (!tenantId) {
+        throw new Error("agent recognition proof: verifier_context.tenant_id is required");
+    }
+    const issuedAt = params.issuedAt ?? new Date(Date.now() - 60_000);
+    const expiresAt = params.expiresAt ?? new Date(issuedAt.getTime() + 4 * 60_000);
+    const issuedAtUtc = new Date(issuedAt.toISOString());
+    const expiresAtUtc = new Date(expiresAt.toISOString());
+    if (expiresAtUtc.getTime() <= issuedAtUtc.getTime()) {
+        throw new Error("agent recognition proof: expires_at must be after issued_at");
+    }
+    if (expiresAtUtc.getTime() - issuedAtUtc.getTime() > AGENT_RECOGNITION_MAX_FRESHNESS_MS) {
+        throw new Error("agent recognition proof: freshness window must not exceed 10m0s");
+    }
+    const nonce = params.nonce?.trim();
+    if (!nonce) {
+        throw new Error("agent recognition proof: nonce is required");
+    }
+    if (nonce.length > 256) {
+        throw new Error("agent recognition proof: nonce must be 256 bytes or fewer");
+    }
+    const requestEnvelope = newAgentRecognitionRequestEnvelope(params.method, params.path, params.body);
+    if (!HEX64_RE.test(requestEnvelope.bodyDigestSha256Hex)) {
+        throw new Error("agent recognition proof: request_envelope.body_digest_sha256_hex must be a lowercase 64-byte hex SHA-256 digest");
+    }
+    return {
+        schemaVersion: AGENT_RECOGNITION_PROOF_SCHEMA_VERSION,
+        kind: AGENT_RECOGNITION_PROOF_KIND_V1,
+        keyId: normalizeScopeToken(params.keyId, "key_id"),
+        signatureAlgorithm: AGENT_RECOGNITION_SIGNATURE_ALGORITHM_ED25519,
+        issuedAt: formatRfc3339Seconds(issuedAtUtc),
+        expiresAt: formatRfc3339Seconds(expiresAtUtc),
+        nonce,
+        purpose: normalizeScopeToken(params.purpose, "purpose"),
+        verifierContext: {
+            tenantId,
+            verifierId: normalizeScopeToken(params.verifierId ?? AGENT_RECOGNITION_GATEWAY_VERIFIER_ID, "verifier_context.verifier_id"),
+        },
+        requestEnvelope,
+    };
+}
+/** Validate, canonicalize, and sign a replay-safe `AgentRecognitionProofV1`. */
+export function signAgentRecognitionProofV1(signingSeed, params) {
+    if (signingSeed.length !== 32) {
+        throw new Error("agent recognition proof: signing key must be an ed25519 private key");
+    }
+    ensureEd25519Sha512Sync();
+    const normalized = normalizeRecognitionProof({
+        ...params,
+        nonce: params.nonce?.trim() || randomUUID(),
+    });
+    const canonical = marshalCanonicalAgentRecognitionProof(normalized);
+    const digest = sha256Hex(canonical);
+    const digestBytes = createHash("sha256").update(canonical).digest();
+    const signature = sign(digestBytes, signingSeed);
+    const publicKey = getPublicKey(signingSeed);
+    return {
+        schema_version: normalized.schemaVersion,
+        kind: normalized.kind,
+        key_id: normalized.keyId,
+        signature_algorithm: normalized.signatureAlgorithm,
+        issued_at: normalized.issuedAt,
+        expires_at: normalized.expiresAt,
+        nonce: normalized.nonce,
+        purpose: normalized.purpose,
+        verifier_context: {
+            tenant_id: normalized.verifierContext.tenantId,
+            verifier_id: normalized.verifierContext.verifierId,
+        },
+        request_envelope: {
+            method: normalized.requestEnvelope.method,
+            path: normalized.requestEnvelope.path,
+            body_digest_sha256_hex: normalized.requestEnvelope.bodyDigestSha256Hex,
+        },
+        message_digest_sha256_hex: digest,
+        signing_public_key_ed25519_hex: bytesToHex(publicKey),
+        ed25519_signature_hex: bytesToHex(signature),
+    };
+}
+/** Build a recognition proof for Gateway `POST /harbor/intents/{intentId}/evidence`. */
+export function signHarborEvidenceSubmitRecognitionProof(input) {
+    return signAgentRecognitionProofV1(input.signingSeed, {
+        keyId: input.keyId,
+        purpose: AGENT_RECOGNITION_PURPOSE_EVIDENCE_SUBMIT,
+        tenantId: input.tenantId,
+        method: "POST",
+        path: `/harbor/intents/${input.intentId}/evidence`,
+        body: input.evidenceBody,
+    });
+}

package/dist/bincode-wire.d.ts

@@ -0,0 +1,18 @@
+/**
+ * bincode 2 `config::standard()` serde wire helpers.
+ * Matches `crates/paybond-evidence/src/wire.rs` (`encode_wire`).
+ */
+/** Signed payload revision for evidence binding (`EvidenceSignV1.version`). */
+export declare const EVIDENCE_SIGN_VERSION = 2;
+/** Completion contract tail revision (`CompletionContractSignV1.version`). */
+export declare const COMPLETION_CONTRACT_SIGN_VERSION = 2;
+export declare function concatBytes(...parts: Uint8Array[]): Uint8Array;
+/** bincode 2 standard unsigned varint (little-endian multi-byte tails). */
+export declare function encodeVarintU64(value: bigint): Uint8Array;
+export declare function encodeVarintU32(n: number): Uint8Array;
+export declare function encodeVarintI64(n: number): Uint8Array;
+export declare function encodeU8(n: number): Uint8Array;
+export declare function encodeBincodeString(s: string): Uint8Array;
+/** UUID serializes as varint-prefixed 16 raw bytes under bincode 2 serde. */
+export declare function encodeBincodeUuid(intentId: string): Uint8Array;
+export declare function encodeFixed32(bytes: Uint8Array): Uint8Array;

package/dist/bincode-wire.js

@@ -0,0 +1,93 @@
+/**
+ * bincode 2 `config::standard()` serde wire helpers.
+ * Matches `crates/paybond-evidence/src/wire.rs` (`encode_wire`).
+ */
+import { parse as parseUuid } from "uuid";
+const SINGLE_BYTE_MAX = 250;
+const U16_BYTE = 251;
+const U32_BYTE = 252;
+const U64_BYTE = 253;
+/** Signed payload revision for evidence binding (`EvidenceSignV1.version`). */
+export const EVIDENCE_SIGN_VERSION = 2;
+/** Completion contract tail revision (`CompletionContractSignV1.version`). */
+export const COMPLETION_CONTRACT_SIGN_VERSION = 2;
+export function concatBytes(...parts) {
+    const n = parts.reduce((a, p) => a + p.length, 0);
+    const out = new Uint8Array(n);
+    let o = 0;
+    for (const p of parts) {
+        out.set(p, o);
+        o += p.length;
+    }
+    return out;
+}
+function zigzagU64(n) {
+    if (n < 0n) {
+        return BigInt.asUintN(64, ~n) * 2n + 1n;
+    }
+    return n * 2n;
+}
+/** bincode 2 standard unsigned varint (little-endian multi-byte tails). */
+export function encodeVarintU64(value) {
+    if (value < 0n) {
+        throw new Error("encodeVarintU64: expected non-negative value");
+    }
+    if (value <= BigInt(SINGLE_BYTE_MAX)) {
+        return new Uint8Array([Number(value)]);
+    }
+    if (value <= 65535n) {
+        const out = new Uint8Array(3);
+        out[0] = U16_BYTE;
+        new DataView(out.buffer).setUint16(1, Number(value), true);
+        return out;
+    }
+    if (value <= 4294967295n) {
+        const out = new Uint8Array(5);
+        out[0] = U32_BYTE;
+        new DataView(out.buffer).setUint32(1, Number(value), true);
+        return out;
+    }
+    if (value <= 18446744073709551615n) {
+        const out = new Uint8Array(9);
+        out[0] = U64_BYTE;
+        new DataView(out.buffer).setBigUint64(1, value, true);
+        return out;
+    }
+    throw new Error("encodeVarintU64: value exceeds u64 range");
+}
+export function encodeVarintU32(n) {
+    if (!Number.isInteger(n) || n < 0) {
+        throw new Error("encodeVarintU32: expected non-negative integer");
+    }
+    return encodeVarintU64(BigInt(n));
+}
+export function encodeVarintI64(n) {
+    if (!Number.isInteger(n)) {
+        throw new Error("encodeVarintI64: expected integer");
+    }
+    return encodeVarintU64(zigzagU64(BigInt(n)));
+}
+export function encodeU8(n) {
+    if (!Number.isInteger(n) || n < 0 || n > 255) {
+        throw new Error("encodeU8: expected u8");
+    }
+    return new Uint8Array([n]);
+}
+export function encodeBincodeString(s) {
+    const utf8 = new TextEncoder().encode(s);
+    return concatBytes(encodeVarintU64(BigInt(utf8.length)), utf8);
+}
+/** UUID serializes as varint-prefixed 16 raw bytes under bincode 2 serde. */
+export function encodeBincodeUuid(intentId) {
+    const intentBytes = parseUuid(intentId);
+    if (intentBytes.length !== 16) {
+        throw new Error("intentId must be a UUID string");
+    }
+    return concatBytes(encodeVarintU64(16n), intentBytes);
+}
+export function encodeFixed32(bytes) {
+    if (bytes.length !== 32) {
+        throw new Error("encodeFixed32: expected 32 bytes");
+    }
+    return bytes;
+}

package/dist/claude-agents/config.d.ts

@@ -0,0 +1,21 @@
+import { createSdkMcpServer, type SdkMcpToolDefinition } from "@anthropic-ai/claude-agent-sdk";
+import type { PaybondAgentRun } from "../agent/run.js";
+/** Pre-built SDK tool from `tool()` in `@anthropic-ai/claude-agent-sdk`. */
+export type ClaudeAgentSdkTool = SdkMcpToolDefinition;
+export type PaybondClaudeAgentsConfigOptions = {
+    /** MCP server name; defaults to `"paybond"`. */
+    serverName?: string;
+    /** Optional version passed to `createSdkMcpServer`. */
+    serverVersion?: string;
+};
+export type ClaudeAgentsConfig = {
+    mcpServer: ReturnType<typeof createSdkMcpServer>;
+    allowedTools: string[];
+    /** Same tool array as input — side-effecting handlers are wrapped in-place. */
+    agentTools: ClaudeAgentSdkTool[];
+};
+/**
+ * Wrap Claude Agent SDK `tool()` handlers with Paybond middleware and bundle them
+ * into an in-process MCP server for `query({ options: { mcpServers, allowedTools } })`.
+ */
+export declare function createPaybondClaudeAgentsConfig(run: PaybondAgentRun, tools: ClaudeAgentSdkTool[], options?: PaybondClaudeAgentsConfigOptions): ClaudeAgentsConfig;

package/dist/claude-agents/config.js

@@ -0,0 +1,145 @@
+import { createSdkMcpServer, } from "@anthropic-ai/claude-agent-sdk";
+import { PaybondAutoEvidenceSubmitError, PaybondUnregisteredSideEffectingToolError, } from "../agent/types.js";
+import { PaybondSpendApprovalRequiredError, PaybondSpendDeniedError, } from "../index.js";
+function claudeMcpAllowedToolName(serverName, toolName) {
+    return `mcp__${serverName}__${toolName}`;
+}
+function resolveClaudeToolCallId(extra) {
+    if (typeof extra === "object" && extra !== null) {
+        const record = extra;
+        for (const key of ["toolUseID", "tool_use_id", "toolCallId", "tool_call_id", "id"]) {
+            const value = record[key];
+            if (typeof value === "string" && value.trim()) {
+                return value.trim();
+            }
+        }
+    }
+    return globalThis.crypto.randomUUID();
+}
+function extractCallToolResultPayload(result) {
+    if (result.structuredContent && typeof result.structuredContent === "object") {
+        return result.structuredContent;
+    }
+    for (const block of result.content) {
+        if (block.type !== "text") {
+            continue;
+        }
+        const text = "text" in block && typeof block.text === "string" ? block.text.trim() : "";
+        if (!text) {
+            continue;
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return { text };
+        }
+    }
+    return result;
+}
+function toCallToolResult(payload) {
+    if (typeof payload === "object" && payload !== null && "content" in payload) {
+        return payload;
+    }
+    if (typeof payload === "string") {
+        return { content: [{ type: "text", text: payload }] };
+    }
+    if (payload === undefined || payload === null) {
+        return { content: [{ type: "text", text: "" }] };
+    }
+    if (typeof payload === "object") {
+        return {
+            content: [{ type: "text", text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    }
+    return { content: [{ type: "text", text: String(payload) }] };
+}
+function paybondErrorCallToolResult(message) {
+    return {
+        content: [{ type: "text", text: message }],
+        isError: true,
+    };
+}
+function assertClaudeAgentSdkTools(tools) {
+    if (!Array.isArray(tools)) {
+        throw new TypeError("claude-agents framework tools must be an array of SDK tool() definitions");
+    }
+    for (const tool of tools) {
+        if (typeof tool !== "object" || tool === null) {
+            throw new TypeError("each claude-agents tool must be an SDK tool() definition");
+        }
+        const record = tool;
+        if (typeof record.name !== "string" || !record.name.trim()) {
+            throw new TypeError("each claude-agents tool must have a non-empty name");
+        }
+        if (typeof record.handler !== "function") {
+            throw new TypeError("each claude-agents tool must have a handler function");
+        }
+    }
+    return tools;
+}
+function wrapClaudeAgentSdkTool(run, sdkTool) {
+    if (!run.registry.isSideEffecting(sdkTool.name)) {
+        return sdkTool;
+    }
+    const originalHandler = sdkTool.handler.bind(sdkTool);
+    const mutableTool = sdkTool;
+    mutableTool.handler = async (args, extra) => {
+        const toolCallId = resolveClaudeToolCallId(extra);
+        try {
+            const wrapped = await run.interceptor.wrapExecute({
+                toolName: sdkTool.name,
+                toolCallId,
+                arguments: args,
+                approvalToken: run.getApprovalToken(toolCallId),
+                execute: async () => {
+                    const mcpResult = await originalHandler(args, extra);
+                    return extractCallToolResultPayload(mcpResult);
+                },
+            });
+            return toCallToolResult(wrapped.toolResult);
+        }
+        catch (err) {
+            if (err instanceof PaybondUnregisteredSideEffectingToolError) {
+                return paybondErrorCallToolResult(`Paybond capability denied: unregistered side-effecting tool (${err.message})`);
+            }
+            if (err instanceof PaybondSpendApprovalRequiredError) {
+                const decisionId = err.result.decisionId;
+                const suffix = decisionId ? ` (decision_id=${decisionId})` : "";
+                const msg = err.result.message ?? err.result.code ?? "approval required";
+                return paybondErrorCallToolResult(`Paybond capability approval required: ${msg}${suffix}`);
+            }
+            if (err instanceof PaybondSpendDeniedError) {
+                const msg = err.result.message ?? err.result.code ?? "capability denied";
+                return paybondErrorCallToolResult(`Paybond capability denied: ${msg}`);
+            }
+            if (err instanceof PaybondAutoEvidenceSubmitError) {
+                return paybondErrorCallToolResult(`Paybond evidence submit failed: ${err.message}`);
+            }
+            throw err;
+        }
+    };
+    return sdkTool;
+}
+/**
+ * Wrap Claude Agent SDK `tool()` handlers with Paybond middleware and bundle them
+ * into an in-process MCP server for `query({ options: { mcpServers, allowedTools } })`.
+ */
+export function createPaybondClaudeAgentsConfig(run, tools, options) {
+    const sdkTools = assertClaudeAgentSdkTools(tools);
+    const serverName = options?.serverName?.trim() || "paybond";
+    for (const sdkTool of sdkTools) {
+        wrapClaudeAgentSdkTool(run, sdkTool);
+    }
+    const mcpServer = createSdkMcpServer({
+        name: serverName,
+        ...(options?.serverVersion ? { version: options.serverVersion } : {}),
+        tools: sdkTools,
+    });
+    return {
+        mcpServer,
+        allowedTools: sdkTools.map((sdkTool) => claudeMcpAllowedToolName(serverName, sdkTool.name)),
+        agentTools: sdkTools,
+    };
+}

package/dist/claude-agents/index.d.ts

@@ -0,0 +1,2 @@
+export { createPaybondClaudeAgentsConfig, type ClaudeAgentSdkTool, type ClaudeAgentsConfig, type PaybondClaudeAgentsConfigOptions, } from "./config.js";
+export { runClaudeAgentsSandboxDemo, type RunClaudeAgentsSandboxDemoInput, type RunClaudeAgentsSandboxDemoResult, } from "./sandbox-demo.js";

package/dist/claude-agents/index.js

@@ -0,0 +1,2 @@
+export { createPaybondClaudeAgentsConfig, } from "./config.js";
+export { runClaudeAgentsSandboxDemo, } from "./sandbox-demo.js";

package/dist/claude-agents/sandbox-demo.d.ts

@@ -0,0 +1,30 @@
+import type { Paybond } from "../index.js";
+export type RunClaudeAgentsSandboxDemoInput = {
+    paybond: Paybond;
+    operation?: string;
+    requestedSpendCents?: number;
+    evidencePreset?: string;
+    toolCallId?: string;
+};
+export type RunClaudeAgentsSandboxDemoResult = {
+    bind: {
+        run_id: string;
+        tenant_id: string;
+        intent_id: string;
+        capability_token: string;
+        operation: string;
+        sandbox_lifecycle_status?: string;
+    };
+    allowed_tools: string[];
+    tool_result?: unknown;
+    evidence: {
+        submitted: boolean;
+        sandbox_lifecycle_status?: string;
+        predicate_passed?: boolean | null;
+    };
+};
+/**
+ * No-LLM Claude Agent SDK sandbox demo: wrapped in-process MCP tool handlers +
+ * auto-evidence.
+ */
+export declare function runClaudeAgentsSandboxDemo(input: RunClaudeAgentsSandboxDemoInput): Promise<RunClaudeAgentsSandboxDemoResult>;

package/dist/claude-agents/sandbox-demo.js

@@ -0,0 +1,91 @@
+import { tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import { createPaybondToolRegistry } from "../agent/registry.js";
+import { createPaybondClaudeAgentsConfig } from "./config.js";
+/**
+ * No-LLM Claude Agent SDK sandbox demo: wrapped in-process MCP tool handlers +
+ * auto-evidence.
+ */
+export async function runClaudeAgentsSandboxDemo(input) {
+    const operation = (input.operation ?? "paid-tool").trim();
+    const requestedSpendCents = input.requestedSpendCents ?? 100;
+    const evidencePreset = (input.evidencePreset ?? "cost_and_completion").trim();
+    const toolCallId = (input.toolCallId ?? "claude-demo-1").trim();
+    const registry = createPaybondToolRegistry({
+        defaultDeny: true,
+        sideEffecting: {
+            [operation]: {
+                operation,
+                evidencePreset,
+                spendCents: requestedSpendCents,
+                evidenceMapper: (result) => {
+                    const payload = result;
+                    return {
+                        status: payload.status,
+                        cost_cents: payload.cost_cents,
+                    };
+                },
+            },
+        },
+    });
+    const run = await input.paybond.agentRun.bind({
+        bootstrap: {
+            kind: "sandbox",
+            operation,
+            requestedSpendCents,
+            completionPreset: evidencePreset,
+        },
+        registry,
+    });
+    const sdkTools = [
+        tool(operation, `Paid operation ${operation}`, { estimatedPriceCents: z.number().int().nonnegative() }, async (args) => ({
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        status: "completed",
+                        cost_cents: args.estimatedPriceCents,
+                    }),
+                },
+            ],
+            structuredContent: {
+                status: "completed",
+                cost_cents: args.estimatedPriceCents,
+            },
+        })),
+    ];
+    const config = createPaybondClaudeAgentsConfig(run, sdkTools);
+    const paidTool = config.agentTools[0];
+    if (!paidTool) {
+        throw new Error("claude-agents sandbox demo missing paid tool");
+    }
+    const mcpResult = await paidTool.handler({ estimatedPriceCents: requestedSpendCents }, { toolUseID: toolCallId });
+    const sandboxStatus = run.binding.sandbox?.sandboxLifecycleStatus;
+    const structured = typeof mcpResult === "object" &&
+        mcpResult !== null &&
+        "structuredContent" in mcpResult &&
+        typeof mcpResult.structuredContent === "object"
+        ? mcpResult.structuredContent
+        : undefined;
+    const isError = typeof mcpResult === "object" &&
+        mcpResult !== null &&
+        "isError" in mcpResult &&
+        Boolean(mcpResult.isError);
+    return {
+        bind: {
+            run_id: run.runId,
+            tenant_id: run.tenantId,
+            intent_id: run.intentId,
+            capability_token: run.capabilityToken,
+            operation,
+            sandbox_lifecycle_status: sandboxStatus,
+        },
+        allowed_tools: config.allowedTools,
+        tool_result: structured,
+        evidence: {
+            submitted: !isError,
+            sandbox_lifecycle_status: sandboxStatus,
+            predicate_passed: !isError ? true : null,
+        },
+    };
+}

package/dist/cli/agent/env-quote.d.ts

@@ -0,0 +1 @@
+export declare function quoteEnvValue(value: string): string;

package/dist/cli/agent/env-quote.js

@@ -0,0 +1,6 @@
+export function quoteEnvValue(value) {
+    if (/^[A-Za-z0-9_./:@+-]+$/.test(value)) {
+        return value;
+    }
+    return JSON.stringify(value);
+}

package/dist/cli/agent/env-write.d.ts

@@ -0,0 +1,8 @@
+export type AgentEnvWriteInput = {
+    envFile: string;
+    cwd: string;
+    intentId: string;
+    capabilityToken: string;
+    runId: string;
+};
+export declare function appendAgentRunEnvVars(input: AgentEnvWriteInput): Promise<string>;