@paybond/kit 0.10.0 → 0.11.1

package/dist/agent/run.js

@@ -0,0 +1,301 @@
+import { PaybondToolInterceptor } from "./interceptor.js";
+import { PaybondAgentRunBindError, } from "./types.js";
+import { reloadPolicyOnRun, } from "../policy/reload.js";
+import { PaybondPolicyReloadController } from "../policy/watcher.js";
+import { resolveDevTraceSink } from "../dev/trace-buffer.js";
+function newRunId(explicit) {
+    const trimmed = explicit?.trim();
+    if (trimmed) {
+        return trimmed;
+    }
+    return globalThis.crypto.randomUUID();
+}
+function readAllowedTools(intent) {
+    const raw = intent.allowed_tools;
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    return raw.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+}
+function normalizeProductionEvidence(raw, sandbox) {
+    if (sandbox !== undefined) {
+        return undefined;
+    }
+    if (!raw) {
+        throw new PaybondAgentRunBindError("attach.productionEvidence is required for production auto-evidence submission");
+    }
+    const payeeDid = raw.payeeDid.trim();
+    const agentRecognitionKeyId = raw.agentRecognitionKeyId.trim();
+    if (!payeeDid) {
+        throw new PaybondAgentRunBindError("attach.productionEvidence requires a payee identity");
+    }
+    if (!agentRecognitionKeyId) {
+        throw new PaybondAgentRunBindError("attach.productionEvidence.agentRecognitionKeyId must be non-empty");
+    }
+    if (raw.payeeSigningSeed.length !== 32) {
+        throw new PaybondAgentRunBindError("attach.productionEvidence.payeeSigningSeed must be 32 bytes");
+    }
+    if (raw.agentRecognitionSigningSeed.length !== 32) {
+        throw new PaybondAgentRunBindError("attach.productionEvidence.agentRecognitionSigningSeed must be 32 bytes");
+    }
+    return {
+        payeeDid,
+        payeeSigningSeed: raw.payeeSigningSeed,
+        agentRecognitionKeyId,
+        agentRecognitionSigningSeed: raw.agentRecognitionSigningSeed,
+    };
+}
+function assertExclusiveBindMode(input) {
+    const hasBootstrap = input.bootstrap !== undefined;
+    const hasAttach = input.attach !== undefined;
+    if (hasBootstrap === hasAttach) {
+        throw new PaybondAgentRunBindError("agent run bind requires exactly one of bootstrap or attach");
+    }
+}
+async function resolveAttachBinding(paybond, attach) {
+    const intentId = attach.intentId.trim();
+    const capabilityToken = attach.capabilityToken.trim();
+    if (!intentId) {
+        throw new PaybondAgentRunBindError("attach.intentId must be non-empty");
+    }
+    if (!capabilityToken) {
+        throw new PaybondAgentRunBindError("attach.capabilityToken must be non-empty");
+    }
+    let allowedTools = attach.allowedTools;
+    if (allowedTools === undefined) {
+        const intent = await paybond.harbor.getIntent(intentId);
+        allowedTools = readAllowedTools(intent);
+    }
+    if (allowedTools.length === 0) {
+        throw new PaybondAgentRunBindError(`attach: intent ${intentId} has no allowed_tools; pass attach.allowedTools explicitly`);
+    }
+    return { intentId, capabilityToken, allowedTools };
+}
+async function resolveSandboxBootstrap(paybond, bootstrap) {
+    if (bootstrap.kind !== "sandbox") {
+        throw new PaybondAgentRunBindError('bootstrap.kind must be "sandbox"');
+    }
+    const operation = bootstrap.operation.trim();
+    if (!operation) {
+        throw new PaybondAgentRunBindError("bootstrap.operation must be non-empty");
+    }
+    if (!Number.isFinite(bootstrap.requestedSpendCents) || bootstrap.requestedSpendCents < 0) {
+        throw new PaybondAgentRunBindError("bootstrap.requestedSpendCents must be a non-negative number");
+    }
+    const bootstrapResult = await paybond.guardrails.bootstrapSandbox({
+        operation,
+        requestedSpendCents: bootstrap.requestedSpendCents,
+        currency: bootstrap.currency,
+        evidenceSchema: bootstrap.evidenceSchema,
+        metadata: bootstrap.metadata,
+        idempotencyKey: bootstrap.idempotencyKey,
+        completionPreset: bootstrap.completionPreset,
+        templateId: bootstrap.templateId,
+        parameters: bootstrap.parameters,
+    });
+    return {
+        binding: {
+            intentId: bootstrapResult.intent_id,
+            capabilityToken: bootstrapResult.capability_token,
+            allowedTools: [bootstrapResult.operation],
+            sandbox: {
+                operation: bootstrapResult.operation,
+                requestedSpendCents: bootstrapResult.requested_spend_cents,
+                sandboxLifecycleStatus: bootstrapResult.sandbox_lifecycle_status,
+            },
+        },
+    };
+}
+/**
+ * Run-scoped agent middleware context for one agent task.
+ * Bind once per run; do not share across concurrent agent tasks.
+ */
+export class PaybondAgentRun {
+    _currentSnapshot;
+    binding;
+    interceptor;
+    policyFilePath;
+    reloadController;
+    approvalTokens = new Map();
+    listeners = new Map();
+    constructor(binding, host, _currentSnapshot, policyFilePath) {
+        this._currentSnapshot = _currentSnapshot;
+        this.binding = binding;
+        this.interceptor = new PaybondToolInterceptor(binding, host);
+        this.policyFilePath = policyFilePath;
+    }
+    /** Start file watcher and/or Gateway poll reload (called from bind when `reload` is set). */
+    startPolicyReload(config) {
+        if (!this.policyFilePath) {
+            throw new Error("startPolicyReload requires policyFilePath from bind");
+        }
+        this.stopPolicyReload();
+        const runner = {
+            reloadPolicy: (options) => this.reloadPolicy(options),
+        };
+        this.reloadController = PaybondPolicyReloadController.start(runner, config, this.policyFilePath);
+    }
+    /** Active policy snapshot for this run (undefined when bind omitted policy tracking). */
+    get currentSnapshot() {
+        return this._currentSnapshot;
+    }
+    /** `sha256:<hex>` digest of the active policy snapshot, when tracked. */
+    get policyDigest() {
+        return this._currentSnapshot?.digest;
+    }
+    /** `{policy_name}@{digest_short}` version label of the active snapshot. */
+    get policyVersion() {
+        return this._currentSnapshot?.version;
+    }
+    /** RFC3339 timestamp when the active policy snapshot was loaded. */
+    get policyLoadedAt() {
+        return this._currentSnapshot?.loadedAt;
+    }
+    /** Active in-flight authorize/execute cycles (blocks policy reload until zero). */
+    get inFlightCount() {
+        return this.interceptor.inFlightCount;
+    }
+    get runId() {
+        return this.binding.runId;
+    }
+    get tenantId() {
+        return this.binding.tenantId;
+    }
+    get intentId() {
+        return this.binding.intentId;
+    }
+    get capabilityToken() {
+        return this.binding.capabilityToken;
+    }
+    get guard() {
+        return this.binding.guard;
+    }
+    get registry() {
+        return this.binding.registry;
+    }
+    get allowedTools() {
+        return this.binding.allowedTools;
+    }
+    /** Subscribe to policy reload lifecycle events. */
+    on(event, listener) {
+        let set = this.listeners.get(event);
+        if (!set) {
+            set = new Set();
+            this.listeners.set(event, set);
+        }
+        set.add(listener);
+    }
+    /** Unsubscribe from policy reload lifecycle events. */
+    off(event, listener) {
+        this.listeners.get(event)?.delete(listener);
+    }
+    emit(event, payload) {
+        for (const listener of this.listeners.get(event) ?? []) {
+            listener(payload);
+        }
+    }
+    /** Atomically swap registry and snapshot on the run binding (Tier 7 hot-reload). */
+    applyPolicySnapshot(snapshot) {
+        this.binding.registry = snapshot.registry;
+        this.binding.policySnapshot = snapshot;
+        this._currentSnapshot = snapshot;
+    }
+    /** Reload policy from disk or Gateway effective resolution without re-binding the run. */
+    async reloadPolicy(options = {}) {
+        try {
+            const result = await reloadPolicyOnRun(this, options);
+            if (result.applied && result.previousDigest && result.newDigest) {
+                this.emit("policyReloaded", {
+                    previousDigest: result.previousDigest,
+                    newDigest: result.newDigest,
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.emit("policyReloadFailed", { error: err });
+            throw error;
+        }
+    }
+    /** Stop background reload watchers started at bind time. */
+    stopPolicyReload() {
+        this.reloadController?.stop();
+    }
+    /** Store an operator approval token for retry after a Harbor approval hold. */
+    storeApprovalToken(toolCallId, token) {
+        const id = toolCallId.trim();
+        const value = token.trim();
+        if (!id) {
+            throw new Error("toolCallId must be non-empty");
+        }
+        if (!value) {
+            throw new Error("approval token must be non-empty");
+        }
+        this.approvalTokens.set(id, value);
+    }
+    /** Read a stored approval token for a tool call retry. */
+    getApprovalToken(toolCallId) {
+        return this.approvalTokens.get(toolCallId.trim());
+    }
+    /** Bind a run-scoped middleware context via sandbox bootstrap or attach. */
+    static async bind(paybond, input) {
+        assertExclusiveBindMode(input);
+        const runId = newRunId(input.runId);
+        const tenantId = paybond.harbor.tenantId;
+        let intentId;
+        let capabilityToken;
+        let allowedTools;
+        let sandbox;
+        let productionEvidence;
+        if (input.bootstrap !== undefined) {
+            const resolved = await resolveSandboxBootstrap(paybond, input.bootstrap);
+            intentId = resolved.binding.intentId;
+            capabilityToken = resolved.binding.capabilityToken;
+            allowedTools = resolved.binding.allowedTools;
+            sandbox = resolved.binding.sandbox;
+            productionEvidence = undefined;
+        }
+        else {
+            const resolved = await resolveAttachBinding(paybond, input.attach);
+            intentId = resolved.intentId;
+            capabilityToken = resolved.capabilityToken;
+            allowedTools = resolved.allowedTools;
+            sandbox = input.attach.sandbox;
+            productionEvidence = normalizeProductionEvidence(input.attach.productionEvidence, sandbox);
+        }
+        const snapshot = input.policySnapshot;
+        const registry = snapshot?.registry ?? input.registry;
+        registry.validateForBind(allowedTools);
+        const guard = paybond.spendGuard(intentId, capabilityToken);
+        const binding = {
+            runId,
+            tenantId,
+            intentId,
+            capabilityToken,
+            guard,
+            registry,
+            allowedTools,
+            sandbox,
+            productionEvidence,
+            policySnapshot: snapshot,
+            onTrace: input.traceSink ?? input.onTrace ?? resolveDevTraceSink(),
+        };
+        const policyFilePath = input.policyFile?.trim();
+        const run = new PaybondAgentRun(binding, paybond, snapshot, policyFilePath);
+        if (input.reload && policyFilePath) {
+            run.startPolicyReload(input.reload);
+        }
+        return run;
+    }
+}
+/** Facade exposed as `paybond.agentRun`. */
+export class PaybondAgentRunFacade {
+    paybond;
+    constructor(paybond) {
+        this.paybond = paybond;
+    }
+    bind(input) {
+        return PaybondAgentRun.bind(this.paybond, input);
+    }
+}

package/dist/agent/types.d.ts

@@ -0,0 +1,318 @@
+/** Context passed to evidence mappers after a successful side-effecting tool call. */
+export type PaybondToolCallContext = {
+    toolName: string;
+    toolCallId: string;
+    operation: string;
+    arguments: unknown;
+};
+/** Resolve requested spend from tool arguments at intercept time. */
+export type PaybondSpendResolver<TArgs = unknown> = (args: TArgs) => number | undefined;
+/** Customize auto-evidence payload extraction from a tool result. */
+export type PaybondEvidenceMapper<TResult = unknown> = (result: TResult, ctx: PaybondToolCallContext) => Record<string, unknown>;
+/** Policy for one registered side-effecting tool. */
+export type PaybondSideEffectingToolPolicy<TArgs = unknown, TResult = unknown> = {
+    /** Harbor `allowed_tools` operation; defaults to the registry key (tool name). */
+    operation?: string;
+    spendCents?: number | PaybondSpendResolver<TArgs>;
+    /** Required completion catalog preset id for auto-evidence. */
+    evidencePreset: string;
+    evidenceMapper?: PaybondEvidenceMapper<TResult>;
+};
+export type PaybondToolRegistryConfig = {
+    sideEffecting?: Record<string, PaybondSideEffectingToolPolicy>;
+    /** When true, deny tool calls whose operation is in intent allowedTools but missing from the registry. */
+    defaultDeny?: boolean;
+};
+export type PaybondSideEffectingToolEntry = {
+    toolName: string;
+    operation: string;
+    spendCents?: number | PaybondSpendResolver;
+    evidencePreset: string;
+    evidenceMapper?: PaybondEvidenceMapper;
+};
+export type PaybondToolResolution = {
+    kind: "passthrough";
+    toolName: string;
+} | {
+    kind: "side_effecting";
+    toolName: string;
+    operation: string;
+    entry: PaybondSideEffectingToolEntry;
+} | {
+    kind: "denied";
+    toolName: string;
+    operation: string;
+    reason: "unregistered_side_effecting";
+};
+export declare class PaybondToolRegistryValidationError extends Error {
+    constructor(message: string);
+}
+import type { PaybondToolRegistry } from "./registry.js";
+import type { PaybondPolicySnapshot } from "../policy/snapshot.js";
+import type { PaybondPolicyReloadBindConfig } from "../policy/reload.js";
+/** Spend authorization input forwarded to the run-bound guard. */
+export type PaybondRunGuardAuthInput = {
+    operation: string;
+    requestedSpendCents?: number;
+    vendorId?: string;
+    taskId?: string;
+    workflowId?: string;
+    toolCallId?: string;
+    toolName?: string;
+    currency?: string;
+    agentSubject?: string;
+    approvalToken?: string;
+    idempotencyKey?: string;
+};
+/** Spend authorization result from Harbor verify. */
+export type PaybondRunGuardAuthResult = {
+    allow: boolean;
+    auditId: string;
+    decisionId?: string;
+    approvalRequired?: boolean;
+};
+/** Sandbox bootstrap input for {@link PaybondAgentRun.bind}. */
+export type PaybondRunBindingSandboxBootstrapInput = {
+    kind: "sandbox";
+    operation: string;
+    requestedSpendCents: number;
+    currency?: string;
+    evidenceSchema?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    idempotencyKey?: string;
+    completionPreset?: string;
+    templateId?: string;
+    parameters?: Record<string, unknown>;
+};
+/** Ed25519 credentials for production auto-evidence (payee binding + agent recognition proof). */
+export type PaybondRunProductionEvidenceCredentials = {
+    payeeDid: string;
+    /** 32-byte Ed25519 seed matching the payee key bound on the intent. */
+    payeeSigningSeed: Uint8Array;
+    /** Tenant-registered trusted agent key id for recognition proofs. */
+    agentRecognitionKeyId: string;
+    /** 32-byte Ed25519 seed matching `agentRecognitionKeyId` in the trusted agent key registry. */
+    agentRecognitionSigningSeed: Uint8Array;
+};
+/** Attach an existing funded intent for {@link PaybondAgentRun.bind}. */
+export type PaybondRunBindingAttachInput = {
+    intentId: string;
+    capabilityToken: string;
+    /** When omitted, allowed tools are loaded from Harbor for the bound intent. */
+    allowedTools?: readonly string[];
+    /** Rehydrate sandbox guardrails evidence routing for attach binds (for example CLI run store). */
+    sandbox?: PaybondRunBinding["sandbox"];
+    /** Required for production attach binds that submit auto-evidence through Gateway Harbor. */
+    productionEvidence?: PaybondRunProductionEvidenceCredentials;
+};
+/** Spend guard handle stored on a run binding for interceptors. */
+export type PaybondRunGuard = {
+    assertSpendAuthorized(input: PaybondRunGuardAuthInput): Promise<PaybondRunGuardAuthResult>;
+    completeSpendAuthorization(decisionId: string, outcome: "consumed" | "released"): Promise<void>;
+};
+export type PaybondInterceptEvidenceResult = {
+    submitted: true;
+    intentId: string;
+    predicatePassed?: boolean | null;
+    sandboxLifecycleStatus?: string;
+    intentState?: string;
+};
+export type PaybondInterceptWrapExecuteResult<TResult> = {
+    toolResult: TResult;
+    authorization?: {
+        allow: true;
+        auditId?: string;
+        decisionId?: string;
+        policyDigest?: string;
+    };
+    evidence?: PaybondInterceptEvidenceResult;
+};
+export type PaybondInterceptWrapExecuteInput<TResult> = {
+    toolName: string;
+    toolCallId: string;
+    arguments: unknown;
+    execute: () => TResult | Promise<TResult>;
+    operation?: string;
+    requestedSpendCents?: number;
+    vendorId?: string;
+    taskId?: string;
+    workflowId?: string;
+    currency?: string;
+    agentSubject?: string;
+    approvalToken?: string;
+    idempotencyKey?: string;
+};
+/** Authorize-only input for pre-execution guard evaluation (no execute, no evidence). */
+export type PaybondAuthorizeToolCallInput = {
+    toolName: string;
+    toolCallId: string;
+    arguments: unknown;
+    operation?: string;
+    requestedSpendCents?: number;
+    vendorId?: string;
+    taskId?: string;
+    workflowId?: string;
+    currency?: string;
+    agentSubject?: string;
+    approvalToken?: string;
+    idempotencyKey?: string;
+};
+export type PaybondToolInputGuardAllowDecision = {
+    kind: "allow";
+    /** True when the tool is read-only and Harbor verify was skipped. */
+    passthrough?: boolean;
+    operation?: string;
+    auditId?: string;
+    decisionId?: string;
+    /** Policy digest pinned at authorize time for audit (Tier 7). */
+    policyDigest?: string;
+};
+export type PaybondToolInputGuardDenyDecision = {
+    kind: "deny";
+    message: string;
+    operation?: string;
+    auditId?: string;
+    code?: string;
+};
+export type PaybondToolInputGuardApprovalRequiredDecision = {
+    kind: "approval_required";
+    message: string;
+    operation?: string;
+    auditId?: string;
+    code?: string;
+};
+/** Framework-neutral pre-execution spend decision. */
+export type PaybondToolInputGuardDecision = PaybondToolInputGuardAllowDecision | PaybondToolInputGuardDenyDecision | PaybondToolInputGuardApprovalRequiredDecision;
+/** Structured middleware trace event (dev observability; opt-in via {@link PaybondAgentRunBindInput.traceSink}). */
+export type PaybondTraceToolSelectedEvent = {
+    type: "tool_selected";
+    runId: string;
+    toolName: string;
+    toolCallId: string;
+    operation: string;
+    recordedAt: string;
+};
+export type PaybondTraceSpendAuthorizedEvent = {
+    type: "spend_authorized";
+    runId: string;
+    toolCallId: string;
+    operation: string;
+    auditId: string;
+    decisionId?: string;
+    amountCents: number;
+    recordedAt: string;
+};
+export type PaybondTraceSpendDeniedEvent = {
+    type: "spend_denied";
+    runId: string;
+    toolCallId: string;
+    operation: string;
+    message: string;
+    auditId?: string;
+    code?: string;
+    recordedAt: string;
+};
+export type PaybondTraceApprovalRequiredEvent = {
+    type: "approval_required";
+    runId: string;
+    toolCallId: string;
+    operation: string;
+    message: string;
+    auditId?: string;
+    code?: string;
+    recordedAt: string;
+};
+export type PaybondTraceToolExecutedEvent = {
+    type: "tool_executed";
+    runId: string;
+    toolCallId: string;
+    operation: string;
+    durationMs: number;
+    recordedAt: string;
+};
+export type PaybondTraceEvidenceSubmittedEvent = {
+    type: "evidence_submitted";
+    runId: string;
+    toolCallId: string;
+    operation: string;
+    evidenceId: string;
+    presetId: string;
+    /** @deprecated Use {@link PaybondTraceEvidenceSubmittedEvent.presetId}. */
+    evidencePreset?: string;
+    sandboxLifecycleStatus?: string;
+    predicatePassed?: boolean | null;
+    recordedAt: string;
+};
+export type PaybondTraceSpendFinalizedEvent = {
+    type: "spend_finalized";
+    runId: string;
+    toolCallId: string;
+    operation: string;
+    status: "consumed" | "released";
+    recordedAt: string;
+};
+export type PaybondTraceEvent = PaybondTraceToolSelectedEvent | PaybondTraceSpendAuthorizedEvent | PaybondTraceSpendDeniedEvent | PaybondTraceApprovalRequiredEvent | PaybondTraceToolExecutedEvent | PaybondTraceEvidenceSubmittedEvent | PaybondTraceSpendFinalizedEvent;
+/** Optional dev observability sink; not enabled in production binds by default. */
+export type PaybondTraceSink = (event: PaybondTraceEvent) => void;
+/** Run-scoped middleware context: one intent + capability per agent task. */
+export type PaybondRunBinding = {
+    runId: string;
+    tenantId: string;
+    intentId: string;
+    capabilityToken: string;
+    guard: PaybondRunGuard;
+    /** Mutable for Tier 7 hot-reload registry swap. */
+    registry: PaybondToolRegistry;
+    allowedTools: readonly string[];
+    sandbox?: {
+        operation: string;
+        requestedSpendCents: number;
+        sandboxLifecycleStatus: string;
+    };
+    /** Production attach credentials for signed payee evidence and recognition proofs. */
+    productionEvidence?: PaybondRunProductionEvidenceCredentials;
+    /** Mutable for Tier 7 hot-reload registry swap. */
+    policySnapshot?: PaybondPolicySnapshot;
+    /** Optional trace sink for dev observability (see {@link PaybondAgentRunBindInput.traceSink}). */
+    onTrace?: PaybondTraceSink;
+};
+export type PaybondAgentRunBindInput = {
+    bootstrap?: PaybondRunBindingSandboxBootstrapInput;
+    attach?: PaybondRunBindingAttachInput;
+    registry: PaybondToolRegistry;
+    /** Optional versioned policy snapshot; registry is taken from the snapshot when set. */
+    policySnapshot?: PaybondPolicySnapshot;
+    /** Optional client correlation id; generated when omitted. */
+    runId?: string;
+    /** Policy file path for hot-reload (watch/poll/manual reload). */
+    policyFile?: string;
+    /** Enable file watcher and/or Gateway poll reload after bind. */
+    reload?: PaybondPolicyReloadBindConfig;
+    /**
+     * Optional dev trace sink; omitted in production binds unless explicitly set.
+     * When `paybond dev loop` activates a collector, bind resolves it automatically.
+     */
+    traceSink?: PaybondTraceSink;
+    /** @deprecated Use {@link PaybondAgentRunBindInput.traceSink}. */
+    onTrace?: PaybondTraceSink;
+};
+export declare class PaybondAgentRunBindError extends Error {
+    constructor(message: string);
+}
+/** Raised when auto-evidence payload construction fails before submit. */
+export declare class PaybondAutoEvidenceError extends Error {
+    constructor(message: string);
+}
+/** Raised when auto-evidence submission fails after a successful tool execution. */
+export declare class PaybondAutoEvidenceSubmitError extends Error {
+    readonly toolResult: unknown;
+    constructor(toolResult: unknown, cause: unknown);
+}
+/** @deprecated Use {@link PaybondAutoEvidenceSubmitError}. */
+export declare const PaybondEvidenceSubmitError: typeof PaybondAutoEvidenceSubmitError;
+/** Raised when `defaultDeny` blocks a side-effecting tool that was not registered. */
+export declare class PaybondUnregisteredSideEffectingToolError extends Error {
+    readonly toolName: string;
+    readonly operation: string;
+    constructor(toolName: string, operation: string);
+}

package/dist/agent/types.js

@@ -0,0 +1,42 @@
+export class PaybondToolRegistryValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PaybondToolRegistryValidationError";
+    }
+}
+export class PaybondAgentRunBindError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PaybondAgentRunBindError";
+    }
+}
+/** Raised when auto-evidence payload construction fails before submit. */
+export class PaybondAutoEvidenceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PaybondAutoEvidenceError";
+    }
+}
+/** Raised when auto-evidence submission fails after a successful tool execution. */
+export class PaybondAutoEvidenceSubmitError extends Error {
+    toolResult;
+    constructor(toolResult, cause) {
+        const message = cause instanceof Error ? cause.message : "auto-evidence submission failed";
+        super(message, cause instanceof Error ? { cause } : undefined);
+        this.name = "PaybondAutoEvidenceSubmitError";
+        this.toolResult = toolResult;
+    }
+}
+/** @deprecated Use {@link PaybondAutoEvidenceSubmitError}. */
+export const PaybondEvidenceSubmitError = PaybondAutoEvidenceSubmitError;
+/** Raised when `defaultDeny` blocks a side-effecting tool that was not registered. */
+export class PaybondUnregisteredSideEffectingToolError extends Error {
+    toolName;
+    operation;
+    constructor(toolName, operation) {
+        super(`side-effecting tool "${toolName}" (operation "${operation}") is in intent allowedTools but not registered`);
+        this.name = "PaybondUnregisteredSideEffectingToolError";
+        this.toolName = toolName;
+        this.operation = operation;
+    }
+}