@paybond/kit 0.10.0 → 0.11.0

package/dist/agent/facade.js

@@ -0,0 +1,112 @@
+import { createPaybondClaudeAgentsConfig } from "../claude-agents/index.js";
+import { createPaybondOpenAIAgentsConfig } from "../openai-agents/index.js";
+import { isKnownPolicyPresetId, resolvePolicyPresetPath } from "../policy/presets.js";
+import { createPaybondVercelAgentConfig } from "../vercel-ai/config.js";
+import { createPaybondGenericAgentConfig, createPaybondGenericInputGuard, } from "./generic-runner.js";
+import { instrumentPaybondAgent, PaybondInstrumentRuntime, } from "./instrument.js";
+const POLICY_PATH_PATTERN = /[/\\]|\.ya?ml$|\.json$/i;
+/**
+ * Resolve a policy preset id (for example `travel`) or pass through file paths and in-memory documents.
+ */
+export function resolveAgentPolicySource(policy) {
+    if (typeof policy !== "string") {
+        return policy;
+    }
+    const trimmed = policy.trim();
+    if (!trimmed) {
+        throw new Error("policy must be a non-empty preset id or file path");
+    }
+    if (POLICY_PATH_PATTERN.test(trimmed)) {
+        return trimmed;
+    }
+    if (isKnownPolicyPresetId(trimmed)) {
+        return resolvePolicyPresetPath(trimmed);
+    }
+    return trimmed;
+}
+/** Normalize {@link CreateGuardedAgentResult} into the quickstart `{ run, tools, hooks, policy }` shape. */
+export function toPaybondAgentResult(result) {
+    const hooks = {};
+    switch (result.framework) {
+        case "generic":
+            hooks.inputGuard = createPaybondGenericInputGuard(result.run);
+            break;
+        case "vercel-ai":
+            if (result.toolApproval) {
+                hooks.toolApproval = result.toolApproval;
+            }
+            break;
+        case "langgraph":
+            if (result.awrapToolCall) {
+                hooks.awrapToolCall = result.awrapToolCall;
+            }
+            if (result.createToolNode) {
+                hooks.createToolNode = result.createToolNode;
+            }
+            break;
+        case "openai-agents":
+            if (result.runConfig) {
+                hooks.runConfig = result.runConfig;
+            }
+            if (result.openAIAgentsAdapter) {
+                hooks.openAIAgentsAdapter = result.openAIAgentsAdapter;
+            }
+            break;
+        case "claude-agents":
+            if (result.claudeAgentsConfig) {
+                hooks.mcpServer = result.claudeAgentsConfig.mcpServer;
+                hooks.allowedTools = result.claudeAgentsConfig.allowedTools;
+            }
+            break;
+        default: {
+            const exhaustive = result.framework;
+            throw new Error(`unsupported guarded agent framework: ${String(exhaustive)}`);
+        }
+    }
+    return {
+        run: result.run,
+        tools: result.agentTools,
+        hooks,
+        policy: result.policy,
+    };
+}
+/** Opinionated quickstart: resolve named presets, then delegate to {@link instrumentPaybondAgent}. */
+export async function createPaybondAgent(paybond, input) {
+    const policy = typeof input.policy === "string" ? resolveAgentPolicySource(input.policy) : input.policy;
+    const result = await instrumentPaybondAgent(paybond, {
+        ...input,
+        policy,
+        sandbox: input.context || input.attach ? false : (input.sandbox ?? true),
+        attach: input.attach,
+        context: input.context,
+    });
+    if (!(result instanceof PaybondInstrumentRuntime)) {
+        throw new Error("paybond.agent() requires sandbox bootstrap or an explicit context");
+    }
+    return {
+        run: result.run,
+        tools: result.tools,
+        hooks: result.hooks,
+        policy: result.policy,
+    };
+}
+/** Wrap tools for an existing bound run without reloading policy. */
+export function wrapPaybondTools(run, tools, options) {
+    const framework = options?.framework ?? "generic";
+    switch (framework) {
+        case "generic":
+            return createPaybondGenericAgentConfig(run, tools).tools;
+        case "vercel-ai":
+            return createPaybondVercelAgentConfig(run, tools).tools;
+        case "openai-agents":
+            return createPaybondOpenAIAgentsConfig(run, tools).tools;
+        case "claude-agents":
+            return createPaybondClaudeAgentsConfig(run, tools).agentTools;
+        case "langgraph":
+            throw new Error('framework "langgraph" does not wrap tools in place; use instrument() or createPaybondLangGraphHooks(run)');
+        default: {
+            const exhaustive = framework;
+            throw new Error(`unsupported framework for wrapTools: ${String(exhaustive)}`);
+        }
+    }
+}

package/dist/agent/gateway-trace-reporter.d.ts

@@ -0,0 +1,28 @@
+import type { PaybondTraceEvent } from "../agent/types.js";
+export type AgentRunUpsertInput = Readonly<{
+    intentId: string;
+    operation?: string;
+    sandbox?: boolean;
+    allowedTools?: readonly string[];
+    completionPreset?: string;
+}>;
+type GatewayJsonWriter = (method: "PUT" | "POST", path: string, body: Record<string, unknown>) => Promise<unknown>;
+/**
+ * Fire-and-forget Gateway trace reporter for console observability.
+ * Failures are swallowed so middleware execution is never blocked on telemetry.
+ */
+export declare class GatewayAgentRunTraceReporter {
+    private readonly writeJSON;
+    private readonly runId;
+    private readonly pending;
+    private registered;
+    constructor(writeJSON: GatewayJsonWriter, runId: string);
+    /** Register run metadata once per bind (idempotent server-side upsert). */
+    registerRun(input: AgentRunUpsertInput): void;
+    /** Append one middleware trace event to the Gateway run timeline. */
+    reportEvent(event: PaybondTraceEvent): void;
+    createSink(input: AgentRunUpsertInput): (event: PaybondTraceEvent) => void;
+    /** Await in-flight Gateway writes (CLI shutdown hooks). */
+    flush(): Promise<void>;
+}
+export {};

package/dist/agent/gateway-trace-reporter.js

@@ -0,0 +1,49 @@
+/**
+ * Fire-and-forget Gateway trace reporter for console observability.
+ * Failures are swallowed so middleware execution is never blocked on telemetry.
+ */
+export class GatewayAgentRunTraceReporter {
+    writeJSON;
+    runId;
+    pending = [];
+    registered = false;
+    constructor(writeJSON, runId) {
+        this.writeJSON = writeJSON;
+        this.runId = runId;
+    }
+    /** Register run metadata once per bind (idempotent server-side upsert). */
+    registerRun(input) {
+        if (this.registered) {
+            return;
+        }
+        this.registered = true;
+        const body = {
+            intent_id: input.intentId,
+            operation: input.operation ?? "",
+            sandbox: input.sandbox ?? false,
+            allowed_tools: [...(input.allowedTools ?? [])],
+            completion_preset: input.completionPreset ?? "",
+        };
+        this.pending.push(this.writeJSON("PUT", `/v1/agent-runs/${encodeURIComponent(this.runId)}`, body)
+            .then(() => undefined)
+            .catch(() => undefined));
+    }
+    /** Append one middleware trace event to the Gateway run timeline. */
+    reportEvent(event) {
+        this.pending.push(this.writeJSON("POST", `/v1/agent-runs/${encodeURIComponent(this.runId)}/trace-events`, {
+            events: [event],
+        })
+            .then(() => undefined)
+            .catch(() => undefined));
+    }
+    createSink(input) {
+        this.registerRun(input);
+        return (event) => {
+            this.reportEvent(event);
+        };
+    }
+    /** Await in-flight Gateway writes (CLI shutdown hooks). */
+    async flush() {
+        await Promise.all(this.pending.splice(0));
+    }
+}

package/dist/agent/generic-runner.d.ts

@@ -0,0 +1,14 @@
+import { type PaybondGenericWrappedToolDefinition, type PaybondToolInputGuardAdapter } from "./adapter.js";
+import type { PaybondAgentRun } from "./run.js";
+/** Wrapped generic tools plus authorize-only pre-checks for unknown frameworks. */
+export type PaybondGenericAgentConfig = {
+    tools: PaybondGenericWrappedToolDefinition[];
+    inputGuard: PaybondToolInputGuardAdapter;
+};
+/** Authorize-only dry run before side-effecting tool execution (framework-neutral). */
+export declare function createPaybondGenericInputGuard(run: PaybondAgentRun): PaybondToolInputGuardAdapter;
+/**
+ * Recommended default when the agent framework is unknown: wrap `{ name, execute }`
+ * tools with full middleware and expose an authorize-only input guard.
+ */
+export declare function createPaybondGenericAgentConfig(run: PaybondAgentRun, tools: unknown): PaybondGenericAgentConfig;

package/dist/agent/generic-runner.js

@@ -0,0 +1,49 @@
+import { createGenericToolExecutor, createToolInputGuardAdapter, } from "./adapter.js";
+function isGenericToolDefinition(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const record = value;
+    return (typeof record.name === "string" &&
+        record.name.trim().length > 0 &&
+        typeof record.execute === "function");
+}
+function normalizeGenericTools(tools) {
+    if (Array.isArray(tools)) {
+        for (const tool of tools) {
+            if (!isGenericToolDefinition(tool)) {
+                throw new TypeError("each generic tool must have a non-empty name and an execute function");
+            }
+        }
+        return tools;
+    }
+    if (typeof tools === "object" && tools !== null) {
+        return Object.entries(tools).map(([name, tool]) => {
+            if (typeof tool === "function") {
+                return { name, execute: tool };
+            }
+            if (typeof tool === "object" && tool !== null && "execute" in tool) {
+                const record = tool;
+                const resolvedName = record.name?.trim() || name;
+                return { ...record, name: resolvedName };
+            }
+            throw new TypeError("generic framework tools must be an array of { name, execute } or a record of executors");
+        });
+    }
+    throw new TypeError("generic framework tools must be an array or record");
+}
+/** Authorize-only dry run before side-effecting tool execution (framework-neutral). */
+export function createPaybondGenericInputGuard(run) {
+    return createToolInputGuardAdapter(run);
+}
+/**
+ * Recommended default when the agent framework is unknown: wrap `{ name, execute }`
+ * tools with full middleware and expose an authorize-only input guard.
+ */
+export function createPaybondGenericAgentConfig(run, tools) {
+    const normalized = normalizeGenericTools(tools);
+    return {
+        tools: createGenericToolExecutor().wrapTools(run, normalized),
+        inputGuard: createPaybondGenericInputGuard(run),
+    };
+}

package/dist/agent/generic-sandbox-demo.d.ts

@@ -0,0 +1,36 @@
+import type { Paybond } from "../index.js";
+export type RunGenericSandboxDemoInput = {
+    paybond: Paybond;
+    operation?: string;
+    requestedSpendCents?: number;
+    evidencePreset?: string;
+    toolCallId?: string;
+};
+export type RunGenericSandboxDemoResult = {
+    bind: {
+        run_id: string;
+        tenant_id: string;
+        intent_id: string;
+        capability_token: string;
+        operation: string;
+        sandbox_lifecycle_status?: string;
+    };
+    authorization: {
+        allow: boolean;
+        audit_id?: string;
+        decision_id?: string;
+    };
+    execute: {
+        tool_result?: unknown;
+        evidence?: {
+            submitted: boolean;
+            sandbox_lifecycle_status?: string;
+            predicate_passed?: boolean | null;
+        };
+    };
+};
+/**
+ * No-LLM agent-agnostic sandbox demo: `createPaybondGenericAgentConfig` +
+ * wrapped execute + auto-evidence.
+ */
+export declare function runGenericSandboxDemo(input: RunGenericSandboxDemoInput): Promise<RunGenericSandboxDemoResult>;

package/dist/agent/generic-sandbox-demo.js

@@ -0,0 +1,82 @@
+import { createPaybondGenericAgentConfig } from "./generic-runner.js";
+import { createPaybondToolRegistry } from "./registry.js";
+async function executePaidTool(args) {
+    return { status: "completed", cost_cents: args.estimatedPriceCents };
+}
+/**
+ * No-LLM agent-agnostic sandbox demo: `createPaybondGenericAgentConfig` +
+ * wrapped execute + auto-evidence.
+ */
+export async function runGenericSandboxDemo(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 ?? "generic-demo-1").trim();
+    const registry = createPaybondToolRegistry({
+        defaultDeny: true,
+        sideEffecting: {
+            [operation]: {
+                operation,
+                evidencePreset,
+                spendCents: (args) => typeof args === "object" &&
+                    args !== null &&
+                    "estimatedPriceCents" in args &&
+                    typeof args.estimatedPriceCents === "number"
+                    ? args.estimatedPriceCents
+                    : 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 config = createPaybondGenericAgentConfig(run, [
+        { name: operation, execute: executePaidTool },
+    ]);
+    const wrapped = config.tools.find((tool) => tool.name === operation);
+    if (!wrapped) {
+        throw new Error(`generic sandbox demo missing wrapped tool ${operation}`);
+    }
+    const wrappedResult = await wrapped.execute({
+        toolName: operation,
+        toolCallId,
+        arguments: { estimatedPriceCents: requestedSpendCents },
+    });
+    const sandboxStatus = run.binding.sandbox?.sandboxLifecycleStatus;
+    return {
+        bind: {
+            run_id: run.runId,
+            tenant_id: run.tenantId,
+            intent_id: run.intentId,
+            capability_token: run.capabilityToken,
+            operation,
+            sandbox_lifecycle_status: sandboxStatus,
+        },
+        authorization: {
+            allow: true,
+            audit_id: wrappedResult.authorization?.auditId,
+            decision_id: wrappedResult.authorization?.decisionId,
+        },
+        execute: {
+            tool_result: wrappedResult.toolResult,
+            evidence: {
+                submitted: wrappedResult.evidence?.submitted ?? false,
+                sandbox_lifecycle_status: sandboxStatus,
+                predicate_passed: wrappedResult.evidence?.predicatePassed ?? null,
+            },
+        },
+    };
+}

package/dist/agent/guarded-agent.d.ts

@@ -0,0 +1,49 @@
+import type { ToolNodeOptions } from "@langchain/langgraph/prebuilt";
+import { createOpenAIAgentsAdapter, type PaybondOpenAIAgentsAdapterOptions } from "../openai-agents/index.js";
+import { PaybondPolicy, type PaybondPolicyLoadSource } from "../policy/load.js";
+import type { PaybondPolicySandboxBootstrapOptions } from "../policy/sandbox-bootstrap.js";
+import type { PolicyValidatorOptions } from "../policy/validate.js";
+import { paybondVercelToolApproval } from "../vercel-ai/tool-approval.js";
+import { type PaybondLangGraphAwrapToolCall } from "../langgraph/awrap-tool-call.js";
+import { paybondToolNode } from "../langgraph/tool-node.js";
+import { type ClaudeAgentsConfig } from "../claude-agents/index.js";
+import type { PaybondToolRegistry } from "./registry.js";
+import type { PaybondAgentRunHost } from "./run.js";
+import { PaybondAgentRun } from "./run.js";
+import type { PaybondRunBindingAttachInput } from "./types.js";
+export type GuardedAgentFramework = "generic" | "openai-agents" | "vercel-ai" | "langgraph" | "claude-agents";
+export type CreateGuardedAgentInput<TTools = unknown> = {
+    policy: PaybondPolicyLoadSource | PaybondPolicy;
+    /** Agent-agnostic wrapping when omitted. Pass a framework only when SDK-specific hooks are required. */
+    framework?: GuardedAgentFramework;
+    tools: TTools;
+    /** Sandbox bootstrap options; ignored when `attach` is set. */
+    bootstrap?: PaybondPolicySandboxBootstrapOptions;
+    attach?: PaybondRunBindingAttachInput;
+    runId?: string;
+    traceSink?: import("./types.js").PaybondTraceSink;
+    /** @deprecated Use {@link CreateGuardedAgentInput.traceSink}. */
+    onTrace?: import("./types.js").PaybondTraceSink;
+    validatePolicy?: boolean | PolicyValidatorOptions;
+    openAIAgentsOptions?: PaybondOpenAIAgentsAdapterOptions;
+};
+export type CreateGuardedAgentResultBase = {
+    run: PaybondAgentRun;
+    policy: PaybondPolicy;
+    registry: PaybondToolRegistry;
+    framework: GuardedAgentFramework;
+    agentTools: unknown;
+    toolApproval?: ReturnType<typeof paybondVercelToolApproval>;
+    awrapToolCall?: PaybondLangGraphAwrapToolCall;
+    createToolNode?: (tools: Parameters<typeof paybondToolNode>[0], options?: ToolNodeOptions) => ReturnType<typeof paybondToolNode>;
+    openAIAgentsAdapter?: ReturnType<typeof createOpenAIAgentsAdapter>;
+    runConfig?: ReturnType<typeof createOpenAIAgentsAdapter>["runConfig"];
+    claudeAgentsConfig?: ClaudeAgentsConfig;
+};
+export type CreateGuardedAgentResult<TTools = unknown> = CreateGuardedAgentResultBase & {
+    agentTools: TTools;
+};
+/** Policy-driven agent factory: load policy, bind a run, and wire framework tools. */
+export declare function createGuardedAgent<TTools>(paybond: PaybondAgentRunHost, input: CreateGuardedAgentInput<TTools>): Promise<CreateGuardedAgentResult<TTools>>;
+/** Alias for {@link createGuardedAgent} matching facade runner naming. */
+export declare const createGuardedAgentRunner: typeof createGuardedAgent;

package/dist/agent/guarded-agent.js

@@ -0,0 +1,100 @@
+import { createOpenAIAgentsAdapter, createPaybondOpenAIAgentsConfig, } from "../openai-agents/index.js";
+import { PaybondPolicy } from "../policy/load.js";
+import { createPaybondVercelAgentConfig } from "../vercel-ai/config.js";
+import { createPaybondLangGraphHooks } from "../langgraph/config.js";
+import { createPaybondClaudeAgentsConfig, } from "../claude-agents/index.js";
+import { createPaybondGenericAgentConfig, } from "./generic-runner.js";
+import { PaybondAgentRun } from "./run.js";
+async function resolvePolicy(source) {
+    if (source instanceof PaybondPolicy) {
+        return source;
+    }
+    return PaybondPolicy.load(source);
+}
+async function maybeValidatePolicy(policy, validatePolicy) {
+    if (!validatePolicy) {
+        return;
+    }
+    const options = validatePolicy === true ? undefined : validatePolicy;
+    const result = await policy.validate(options);
+    if (!result.valid) {
+        const messages = result.errors.map((entry) => entry.message).join("; ");
+        throw new Error(`policy validation failed: ${messages}`);
+    }
+}
+async function bindGuardedRun(paybond, policy, input) {
+    const registry = policy.toToolRegistry();
+    const bindInput = {
+        registry,
+        runId: input.runId,
+        traceSink: input.traceSink,
+        onTrace: input.onTrace,
+    };
+    if (input.attach) {
+        bindInput.attach = input.attach;
+    }
+    else {
+        bindInput.bootstrap = policy.sandboxBootstrap(input.bootstrap ?? {});
+    }
+    return PaybondAgentRun.bind(paybond, bindInput);
+}
+/** Policy-driven agent factory: load policy, bind a run, and wire framework tools. */
+export async function createGuardedAgent(paybond, input) {
+    const policy = await resolvePolicy(input.policy);
+    await maybeValidatePolicy(policy, input.validatePolicy);
+    const registry = policy.toToolRegistry();
+    const run = await bindGuardedRun(paybond, policy, input);
+    const base = { run, policy, registry };
+    const framework = input.framework ?? "generic";
+    switch (framework) {
+        case "generic": {
+            const config = createPaybondGenericAgentConfig(run, input.tools);
+            return { ...base, framework: "generic", agentTools: config.tools };
+        }
+        case "vercel-ai": {
+            const config = createPaybondVercelAgentConfig(run, input.tools);
+            return {
+                ...base,
+                framework: "vercel-ai",
+                agentTools: config.tools,
+                toolApproval: config.toolApproval,
+            };
+        }
+        case "openai-agents": {
+            const config = createPaybondOpenAIAgentsConfig(run, input.tools, input.openAIAgentsOptions);
+            const adapter = createOpenAIAgentsAdapter(run, input.openAIAgentsOptions);
+            return {
+                ...base,
+                framework: "openai-agents",
+                agentTools: config.tools,
+                openAIAgentsAdapter: adapter,
+                runConfig: config.runConfig,
+            };
+        }
+        case "langgraph": {
+            const hooks = createPaybondLangGraphHooks(run);
+            return {
+                ...base,
+                framework: "langgraph",
+                agentTools: input.tools,
+                awrapToolCall: hooks.awrapToolCall,
+                createToolNode: hooks.createToolNode,
+            };
+        }
+        case "claude-agents": {
+            const claudeAgentsConfig = createPaybondClaudeAgentsConfig(run, input.tools);
+            return {
+                ...base,
+                framework: "claude-agents",
+                agentTools: claudeAgentsConfig.agentTools,
+                claudeAgentsConfig,
+            };
+        }
+        default: {
+            const exhaustive = framework;
+            throw new Error(`unsupported guarded agent framework: ${String(exhaustive)}`);
+        }
+    }
+}
+/** Alias for {@link createGuardedAgent} matching facade runner naming. */
+export const createGuardedAgentRunner = createGuardedAgent;

package/dist/agent/index.d.ts

@@ -0,0 +1,13 @@
+export { createGuardedAgent, createGuardedAgentRunner, type CreateGuardedAgentInput, type CreateGuardedAgentResult, type CreateGuardedAgentResultBase, type GuardedAgentFramework, } from "./guarded-agent.js";
+export { createPaybondAgent, resolveAgentPolicySource, toPaybondAgentResult, wrapPaybondTools, type PaybondAgentHooks, type PaybondAgentInput, type PaybondAgentResult, type PaybondInstrumentInput, type PaybondWrapToolsOptions, } from "./facade.js";
+export { PaybondInstrumentBuilder, PaybondInstrumented, PaybondInstrumentRuntime, PaybondLazyContextError, PaybondUnboundContextError, discoverPolicyFromAgent, discoverToolNames, discoverToolsFromAgent, inlinePolicyToDocument, instrumentPaybondAgent, instrumentPaybondClaudeAgents, instrumentPaybondLangGraph, instrumentPaybondMCP, instrumentPaybondOpenAI, instrumentPaybondVercel, isInlinePolicy, isInstrumentableAgentObject, readPaybondAgentInstrumentation, type PaybondAgentInstrumentation, type PaybondInlinePolicy, type PaybondInstrumentAgentOptions, type PaybondInstrumentAttachInput, type PaybondInstrumentBinding, type PaybondInstrumentContext, type PaybondInstrumentContextInput, type PaybondInstrumentContextProvider, } from "./instrument.js";
+export { formatPaybondAttachEnvSnippet, openPaybondAttachBundle, PAYBOND_ATTACH_BUNDLE_ENV, PAYBOND_ATTACH_BUNDLE_PREFIX, PAYBOND_ATTACH_INTENT_ID_ENV, PAYBOND_CAPABILITY_TOKEN_ENV, productionEvidenceFromAttachBundle, resolveAttachContextFromEnv, sealPaybondAttachBundle, type PaybondAttachBundlePayloadV1, type PaybondAttachEnvRecord, } from "./attach-bundle.js";
+export { createPaybondGenericAgentConfig, createPaybondGenericInputGuard, type PaybondGenericAgentConfig, } from "./generic-runner.js";
+export { runGenericSandboxDemo, type RunGenericSandboxDemoInput, type RunGenericSandboxDemoResult, } from "./generic-sandbox-demo.js";
+export { PaybondFrameworkAdapter, createGenericToolExecutor, createToolInputGuardAdapter, paybondGenericToolExecutorAdapter, paybondToolInputGuardAdapter, type PaybondGenericToolCall, type PaybondGenericToolDefinition, type PaybondGenericWrappedToolDefinition, type PaybondToolInputGuardAdapter, } from "./adapter.js";
+export { buildAutoEvidencePayload, type BuiltAutoEvidence } from "./evidence.js";
+export { PaybondToolInterceptor } from "./interceptor.js";
+export { PaybondToolRegistry, createPaybondToolRegistry, } from "./registry.js";
+export { PaybondAgentRun, PaybondAgentRunFacade, type PaybondAgentRunHost, } from "./run.js";
+export { agentRegistryDocumentToConfig, buildSmokeRegistry, loadAgentRegistryFile, parseAgentRegistryText, validateAgentRegistryDocument, type AgentRegistryFileDocument, type AgentRegistryValidationResult, } from "./registry-file.js";
+export { PaybondAgentRunBindError, PaybondAutoEvidenceError, PaybondAutoEvidenceSubmitError, PaybondEvidenceSubmitError, PaybondToolRegistryValidationError, PaybondUnregisteredSideEffectingToolError, type PaybondAgentRunBindInput, type PaybondAuthorizeToolCallInput, type PaybondEvidenceMapper, type PaybondInterceptEvidenceResult, type PaybondInterceptWrapExecuteInput, type PaybondInterceptWrapExecuteResult, type PaybondRunBinding, type PaybondRunBindingAttachInput, type PaybondRunBindingSandboxBootstrapInput, type PaybondRunProductionEvidenceCredentials, type PaybondRunGuard, type PaybondSideEffectingToolEntry, type PaybondSideEffectingToolPolicy, type PaybondSpendResolver, type PaybondToolCallContext, type PaybondToolInputGuardAllowDecision, type PaybondToolInputGuardApprovalRequiredDecision, type PaybondToolInputGuardDecision, type PaybondToolInputGuardDenyDecision, type PaybondToolRegistryConfig, type PaybondToolResolution, type PaybondTraceEvent, type PaybondTraceSink, } from "./types.js";

package/dist/agent/index.js

@@ -0,0 +1,13 @@
+export { createGuardedAgent, createGuardedAgentRunner, } from "./guarded-agent.js";
+export { createPaybondAgent, resolveAgentPolicySource, toPaybondAgentResult, wrapPaybondTools, } from "./facade.js";
+export { PaybondInstrumentBuilder, PaybondInstrumented, PaybondInstrumentRuntime, PaybondLazyContextError, PaybondUnboundContextError, discoverPolicyFromAgent, discoverToolNames, discoverToolsFromAgent, inlinePolicyToDocument, instrumentPaybondAgent, instrumentPaybondClaudeAgents, instrumentPaybondLangGraph, instrumentPaybondMCP, instrumentPaybondOpenAI, instrumentPaybondVercel, isInlinePolicy, isInstrumentableAgentObject, readPaybondAgentInstrumentation, } from "./instrument.js";
+export { formatPaybondAttachEnvSnippet, openPaybondAttachBundle, PAYBOND_ATTACH_BUNDLE_ENV, PAYBOND_ATTACH_BUNDLE_PREFIX, PAYBOND_ATTACH_INTENT_ID_ENV, PAYBOND_CAPABILITY_TOKEN_ENV, productionEvidenceFromAttachBundle, resolveAttachContextFromEnv, sealPaybondAttachBundle, } from "./attach-bundle.js";
+export { createPaybondGenericAgentConfig, createPaybondGenericInputGuard, } from "./generic-runner.js";
+export { runGenericSandboxDemo, } from "./generic-sandbox-demo.js";
+export { createGenericToolExecutor, createToolInputGuardAdapter, paybondGenericToolExecutorAdapter, paybondToolInputGuardAdapter, } from "./adapter.js";
+export { buildAutoEvidencePayload } from "./evidence.js";
+export { PaybondToolInterceptor } from "./interceptor.js";
+export { PaybondToolRegistry, createPaybondToolRegistry, } from "./registry.js";
+export { PaybondAgentRun, PaybondAgentRunFacade, } from "./run.js";
+export { agentRegistryDocumentToConfig, buildSmokeRegistry, loadAgentRegistryFile, parseAgentRegistryText, validateAgentRegistryDocument, } from "./registry-file.js";
+export { PaybondAgentRunBindError, PaybondAutoEvidenceError, PaybondAutoEvidenceSubmitError, PaybondEvidenceSubmitError, PaybondToolRegistryValidationError, PaybondUnregisteredSideEffectingToolError, } from "./types.js";