@haven_ai/sdk 0.1.17-alpha.0 → 0.1.19-alpha.0

package/dist/index.d.cts

@@ -1,5 +1,59 @@
 import { PaymentRequirements } from 'x402/types';
 
+/**
+ * Verifiable payment receipts.
+ *
+ * A self-contained proof bundle for a settled Haven payment that anyone can
+ * verify **independently of Haven**. The anchor is the agent delegate's
+ * signature over the on-chain transfer hash: recover the signer and confirm it
+ * is the agent's delegate, and you have cryptographic proof the agent authorised
+ * exactly this transfer — no need to trust Haven's backend. The on-chain
+ * `txHash` is the settlement source of truth (verify on any explorer).
+ *
+ * This lives in the SDK so agents and users can verify receipts client-side
+ * with zero Haven trust.
+ */
+declare const RECEIPT_VERSION = "haven-receipt-1";
+interface PaymentReceipt {
+    version: typeof RECEIPT_VERSION;
+    paymentId: string;
+    payment: {
+        token: string;
+        tokenAddress: string;
+        amount: string;
+        amountSek: string | null;
+        recipient: string;
+        safe: string;
+        chainId: number;
+        settledAt: string | null;
+        resourceUrl: string | null;
+    };
+    /** The agent's cryptographic authorisation — what makes the receipt verifiable. */
+    authorization: {
+        delegate: string;
+        signHash: string;
+        signature: string | null;
+    };
+    onChain: {
+        txHash: string | null;
+        chainId: number;
+    };
+}
+type ReceiptVerification = {
+    verified: true;
+    recoveredSigner: string;
+} | {
+    verified: false;
+    reason: 'missing_signature' | 'bad_signature' | 'signer_mismatch';
+    recoveredSigner?: string;
+};
+/**
+ * Verify a receipt independently: recover the signer from the authorisation and
+ * confirm it is the agent's delegate. Pure — `recover` is injectable but
+ * defaults to standard ECDSA recovery, so this runs anywhere (no Haven backend).
+ */
+declare function verifyPaymentReceipt(receipt: PaymentReceipt, recover?: (hash: string, signature: string) => string): ReceiptVerification;
+
 interface HavenClientConfig {
     /** Haven API key (sk_agent_xxx) */
     apiKey: string;
@@ -51,6 +105,25 @@ interface PaymentRequest {
 interface SignData {
     /** The hash to sign (keccak256, 0x-prefixed) */
     hash: string;
+    /**
+     * Delegation rail: 'eip712_userop' (funding redemption) or
+     * 'eip712_delegation' (erc7710 settlement child). Absent = legacy
+     * AllowanceModule (raw ECDSA over `hash`). The session rail's
+     * 'eip191_userop' is retired (#834).
+     *
+     * When present, `hash` is NOT what gets signed — `typed_data` is (#1138).
+     */
+    signature_scheme?: 'eip712_userop' | 'eip712_delegation';
+    /**
+     * EIP-712 payload the account validates, signed VERBATIM (#829). Present
+     * whenever `signature_scheme` is — never reconstruct it from `components`.
+     */
+    typed_data?: {
+        domain: Record<string, unknown>;
+        types: Record<string, unknown>;
+        primaryType: string;
+        message: Record<string, unknown>;
+    };
     /** Breakdown of values that were hashed — useful for debugging */
     components: {
         safe: string;
@@ -98,6 +171,23 @@ interface PaymentResult {
     submittedAt: string | null;
     confirmedAt: string | null;
     expiresAt: string;
+    /**
+     * Platform fee surfaced on the result so it's never silently collected. Dark
+     * today (`amount` "0", `applied` false); always present so it's visible the
+     * moment fees go live.
+     */
+    fee?: PaymentFee | null;
+}
+/** The Haven platform fee applied to a payment (#386). */
+interface PaymentFee {
+    /** Human-readable fee amount ("0" while the fee module is dark). */
+    amount: string;
+    /** Token the fee is denominated in. */
+    token: string;
+    /** Fee as basis points of gross (0 while dark). */
+    basisPoints: number;
+    /** True when a non-zero fee was actually applied. */
+    applied: boolean;
 }
 /** Payment requirements from an HTTP 402 response (x402 protocol). */
 interface X402PaymentRequired {
@@ -195,6 +285,12 @@ interface X402Intent {
     network: string;
     /** Haven-authenticated binding over the x402 expected context. */
     expectedAuth: X402ExpectedAuth;
+    /**
+     * EIP-712 digest of `signData.typed_data`, present on the delegation rail
+     * (#1138). The edge signer needs it to reconstruct the v2 expected-context
+     * message that Haven signed.
+     */
+    expectedTypedDataHash?: string;
     /** Delegate EOA the funding transfer tops up (the x402 payer). */
     fundingTo: string;
 }
@@ -208,9 +304,33 @@ interface X402ExpectedContext {
     network: string;
     /** Optional ISO expiry for the funding/quote window. When present, it is bound into the Haven-authenticated context. */
     expiresAt?: string;
+    /**
+     * EIP-712 digest of the typed data the account actually validates
+     * (delegation rail, #1138). Present ⇒ the context is **version 2** and the
+     * signer must sign that typed data, never `payloadHash`.
+     *
+     * On the delegation rail `payloadHash` is the bare ERC-4337 UserOp hash,
+     * which is NOT what the account validates — binding it alone would leave the
+     * edge signer unable to verify the payload it is being asked to sign. Binding
+     * this digest makes Haven's declaration cover the real payload.
+     */
+    typedDataHash?: string;
 }
 interface X402ExpectedAuth {
-    version: 1;
+    /**
+     * 1 = hash-only (legacy rail). 2 = carries `typedDataHash` (delegation rail,
+     * #1138).
+     *
+     * Deliberately `number`, not a literal union (#1143). This is an **inbound**
+     * value: a signer parses a context Haven produced, and a signer older than the
+     * backend will legitimately receive a version it does not know. A closed union
+     * makes that state unrepresentable, which pushed the rejection down to the
+     * schema boundary and produced a raw validation error naming neither the cause
+     * nor the fix. The supported set lives in the signer
+     * (`SUPPORTED_X402_EXPECTED_VERSIONS`), which fails closed on anything outside
+     * it with an actionable message.
+     */
+    version: number;
     message: string;
     signature: string;
     signer: string;
@@ -417,10 +537,17 @@ interface HavenAllowanceSummary {
 }
 /**
  * Affirmative spend-readiness for the authenticated agent, derived from the raw
- * agent status plus the on-chain remaining allowance:
- * - `ready`         — active and at least one token has remaining on-chain allowance.
- * - `needs_approval`— active but no remaining allowance to auto-spend; payments
- *                     will be queued for the wallet owner to approve in Haven.
+ * agent status plus the remaining spend authority the backend reports per rail
+ * (the on-chain AllowanceModule on the legacy rail; the active budget
+ * delegation on the delegation rail — #1135):
+ * - `ready`         — active and at least one token has remaining spend authority.
+ * - `needs_approval`— active but no remaining spend authority to auto-spend.
+ *                     The over-budget outcome differs by rail: on the legacy
+ *                     AllowanceModule rail the payment is queued for the wallet
+ *                     owner to approve in Haven; on the delegation rail there is
+ *                     NO approval queue — an over-budget redemption reverts
+ *                     on-chain, so the owner must grant or raise the budget in
+ *                     Haven before the agent can pay.
  * - `revoked`       — the agent's status is not `active`; nothing auto-executes.
  *
  * Note: a hard-paused/disabled credential is rejected by the API before this
@@ -660,6 +787,8 @@ interface PaymentStatusResult {
     expiresAt: string;
     chainId: number;
     message: string;
+    /** Platform fee surfaced so it's never silently collected (#386). */
+    fee?: PaymentFee | null;
     amountAtomic?: string | null;
     asset?: string | null;
     network?: string | null;
@@ -754,8 +883,14 @@ declare class HavenTimeoutError extends HavenError {
  */
 /** Base mainnet. The only chain Haven sweeps today. */
 declare const SWEEP_BASE_CHAIN_ID = 8453;
+/** Base Sepolia testnet — used by the dev environment / QA harness. */
+declare const SWEEP_BASE_SEPOLIA_CHAIN_ID = 84532;
 /** Canonical Circle USDC on Base (FiatTokenV2_2). */
 declare const SWEEP_BASE_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+/** Circle's canonical Base Sepolia testnet USDC. */
+declare const SWEEP_BASE_SEPOLIA_USDC_ADDRESS = "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
+/** True when the gasless sweep supports a chain (its USDC domain + address are known). */
+declare function isSweepableChain(chainId: number): boolean;
 /** EIP-712 `TransferWithAuthorization` struct, per EIP-3009. */
 declare const TRANSFER_WITH_AUTHORIZATION_TYPES: {
     readonly TransferWithAuthorization: readonly [{
@@ -815,7 +950,13 @@ interface SweepAuthorization {
  * hosted server pointing `to` at an attacker) before it signs.
  */
 interface SweepExpectedAuth {
-    version: 1;
+    /**
+     * Currently always 1. Typed as `number` for the same reason as
+     * `X402ExpectedAuth.version` (#1143): it is inbound, so a stale signer must be
+     * able to *receive* an unknown version in order to report it. The signer's
+     * `SUPPORTED_SWEEP_BINDING_VERSIONS` is the authority on what it will sign.
+     */
+    version: number;
     message: string;
     signature: string;
     signer: string;
@@ -829,7 +970,15 @@ interface SweepPreparation {
 interface SweepPrepareResponse {
     /** Present and true when the delegate holds nothing to recover. */
     nothing_stranded?: boolean;
-    /** The authorization to sign — absent when nothing is stranded. */
+    /**
+     * Present and true when the stranded balance is below the sweep floor (#700):
+     * it is left on the delegate as dust rather than recovered, because the gas to
+     * sweep it would exceed its value. `min_usdc` carries the configured floor. No
+     * `authorization` is built.
+     */
+    below_min?: boolean;
+    min_usdc?: string;
+    /** The authorization to sign — absent when nothing is stranded or below the floor. */
     authorization?: SweepAuthorization;
     /** Haven's binding over the authorization — absent when nothing is stranded. */
     expected_auth?: SweepExpectedAuth;
@@ -981,6 +1130,16 @@ declare class HavenClient {
      * Requires `delegateKey` to be set in the client config.
      */
     sign(hash: string): string;
+    /**
+     * Sign a payment's `sign_data` with the correct scheme for its rail.
+     *
+     * Dispatching on the server-provided scheme means a caller never has to
+     * know which rail an account is on; an unknown scheme is a hard error,
+     * never a guessed signature. The session rail's 'eip191_userop' is retired
+     * (#834) — the backend refuses those intents with HTTP 410 before any
+     * sign_data reaches a client, so encountering it here is a hard error too.
+     */
+    private signForData;
     /**
      * Step 3: Submit a signature to execute the payment.
      *
@@ -1061,6 +1220,16 @@ declare class HavenClient {
     listReceipts(options?: {
         limit?: number;
     }): Promise<HavenPaymentReceipt[]>;
+    /**
+     * Fetch the verifiable receipt bundle for a settled payment and verify it
+     * locally. The server's own verification is ignored — the receipt is verified
+     * here (independently of Haven) by recovering the signer from the
+     * authorisation, so the result is trustworthy even if the backend lied.
+     */
+    getReceipt(paymentId: string): Promise<{
+        receipt: PaymentReceipt;
+        verification: ReceiptVerification;
+    }>;
     /**
      * Rehydrate the x402/MPP resume-state bundle for a payment id.
      *
@@ -1153,6 +1322,19 @@ declare class HavenClient {
      */
     payMppChallenge(quote: MppQuote, options?: MppAuthorizationOptions): Promise<Response>;
     private retryX402Request;
+    /**
+     * #956: capture the merchant's OWN receipt when the paid response carries
+     * one, and report it to Haven so the reporting feed can attach it next to
+     * the Haven-generated payment evidence (#498). Two supported signals on the
+     * paid response:
+     *
+     *   x-receipt-json: base64-encoded JSON receipt document (inline)
+     *   x-receipt-url:  https URL to the receipt document (reference)
+     *
+     * Strictly best-effort: absence is the normal case, and no failure here may
+     * ever affect the completed payment — the response is already paid for.
+     */
+    private reportMerchantReceipt;
     /**
      * Deliver an already-signed x402 payment header to the merchant and return
      * the merchant's response. Used by the hosted MCP server to complete the
@@ -1327,6 +1509,21 @@ declare const havenTools: {
  * Uses ethers.SigningKey.sign() instead of wallet.signMessage() to avoid the prefix.
  */
 declare function signHash(privateKey: string, hash: string): string;
+/**
+ * Sign a delegation-rail payment (#829).
+ *
+ * The delegate SMART ACCOUNT validates an EIP-712 signature over the packed
+ * UserOperation — signing the bare 4337 hash would be rejected on-chain. The
+ * backend sends the exact typed data in `sign_data.typed_data`; we sign it
+ * verbatim and never reconstruct it (a second source of truth could drift
+ * from the account's own rules).
+ */
+declare function signUserOpTypedDataForDelegation(privateKey: string, typedData: {
+    domain: Record<string, unknown>;
+    types: Record<string, unknown>;
+    primaryType: string;
+    message: Record<string, unknown>;
+}): Promise<string>;
 /**
  * Derive the Ethereum address from a private key.
  */
@@ -1424,13 +1621,13 @@ declare const toolDescriptions: {
     readonly getAgent: {
         readonly summary: "Return the authenticated agent identity AND its live spend authority in one call: Haven wallet, delegate, chain, raw status, a readiness signal, and per-token remaining allowance (atomic + human-readable). The recommended first call in a new session to confirm who you are and whether you can pay right now.";
         readonly selectionGuidance: "Use this as the one-shot orientation/bootstrap at the start of a session, or whenever you need to confirm identity together with whether the agent can spend right now. For a detailed per-token breakdown (configured vs spent vs reset window) use haven_get_allowances.";
-        readonly behavior: "Reads identity plus the on-chain AllowanceModule snapshot in one shot. readiness is \"ready\" when at least one token has remaining on-chain allowance, \"needs_approval\" when the agent is active but has no remaining allowance to auto-spend (payments will be queued for the wallet owner to approve in Haven), and \"revoked\" when the credential is not active. allowances[] carries remainingAtomic and remainingDisplay per token. Identity fields (id, name, status, safeAddress, delegateAddress, chainId) are unchanged from before.";
+        readonly behavior: "Reads identity plus the live spend-authority snapshot in one shot — the on-chain AllowanceModule on the legacy rail, the active budget delegation on the delegation rail. readiness is \"ready\" when at least one token has remaining spend authority, \"needs_approval\" when the agent is active but has none, and \"revoked\" when the credential is not active. What an over-budget payment does differs by rail: on the legacy AllowanceModule rail it is queued for the wallet owner to approve in Haven; on the delegation rail there is no approval queue — an over-budget redemption reverts on-chain, so ask the owner to grant or raise the budget in Haven rather than waiting for an approval. allowances[] carries remainingAtomic and remainingDisplay per token. Identity fields (id, name, status, safeAddress, delegateAddress, chainId) are unchanged from before.";
         readonly nextActionGuidance: "";
     };
     readonly getAllowances: {
         readonly summary: "Return configured and on-chain allowance state for the authenticated agent. On-chain allowance is the real spend gate.";
         readonly selectionGuidance: "Use this when the user asks about allowance, budget, spend limit, remaining amount, remaining allowance, remaining budget, daily limit, reset period, what can I spend, or what the agent can still spend.";
-        readonly behavior: "Reads the Safe AllowanceModule snapshot per token (allowance, spent, remaining, reset window). Configured amounts from Haven are returned alongside the on-chain truth.";
+        readonly behavior: "Returns the per-token spend authority for the account's rail: the Safe AllowanceModule snapshot (allowance, spent, remaining, reset window) on the legacy rail, or the active budget delegation (remaining = the period budget; over-budget redemptions revert on-chain, nothing queues) on the delegation rail. Configured amounts from Haven are returned alongside.";
         readonly nextActionGuidance: "";
     };
     readonly listReceipts: {
@@ -1439,6 +1636,12 @@ declare const toolDescriptions: {
         readonly behavior: "Returns the agent's recent machine-payment receipts ordered by recency. Proof header values are not returned.";
         readonly nextActionGuidance: "";
     };
+    readonly verifyReceipt: {
+        readonly summary: "Verify a payment receipt offline — confirm the agent authorised the transfer.";
+        readonly selectionGuidance: "Use this to check a receipt you already hold; it needs no network and does not trust Haven. Use the history tool to fetch receipts in the first place.";
+        readonly behavior: "Recovers the signer from the receipt authorisation and confirms it matches the agent delegate. Returns verified true/false with the recovered signer or a reason. Pure and local — no backend call.";
+        readonly nextActionGuidance: "";
+    };
     readonly payMcpTool: {
         readonly summary: "Call a named tool on an MCP merchant that requires an x402 payment, handling the full initialize → pay → retry round trip.";
         readonly selectionGuidance: string;
@@ -1489,6 +1692,75 @@ declare const HAVEN_SKILL_MD = "---\nname: haven-pay\ndescription: Pay for thing
 /** Directory name for the installed skill folder. */
 declare const SKILL_FOLDER_NAME = "haven-pay";
 
+/**
+ * The Node.js floor Haven's published packages support (#1161).
+ *
+ * ## Why this lives in the SDK
+ *
+ * Three packages need to enforce the same floor — `connect` (at setup),
+ * `signer` and `mcp` (at startup) — and `@haven_ai/sdk` is the only dependency
+ * all three already share. A copy per package is how the floor drifted in the
+ * first place: `engines` said `>=24` everywhere while connect's runtime manifest
+ * enforced `20.0.0`, so a connect run on Node v23 passed the guard, installed
+ * the signer, and signed a real payment. Two numbers for one fact is one number
+ * too many.
+ *
+ * Each consumer still owns its own refusal — the error type, the exit code, the
+ * wording of "what to do next" — because a library must never terminate its
+ * host process. This module only answers *is this version supported* and *what
+ * should we tell the user*.
+ *
+ * ## Why a floor is enforced at all
+ *
+ * `engines` is advisory: npm emits `EBADENGINE` and installs anyway unless the
+ * user happens to have `engine-strict` set. For a normal library that is a
+ * reasonable default. For the **signer** it is not — it holds the delegate key
+ * and produces every payment signature, so a subtle runtime incompatibility
+ * shows up as a wrong or missing signature on a money path. "It seemed to work"
+ * is precisely the evidence that cannot be relied on there.
+ */
+/**
+ * The minimum supported Node.js version, as `major.minor.patch`.
+ *
+ * MUST equal the `engines.node` floor declared by every published Haven
+ * package. A guard test in each package asserts exactly that against its own
+ * `package.json`, so the two cannot drift again silently.
+ */
+declare const HAVEN_MINIMUM_NODE_VERSION = "24.0.0";
+/**
+ * Compare two Node versions. Negative when `left` is older.
+ *
+ * An unparseable version parses to `0.0.0` and therefore compares as older than
+ * any real floor — fail-closed. A version string Haven cannot read is not
+ * evidence of a supported runtime, and treating it as one would reopen exactly
+ * the hole this module closes.
+ */
+declare function compareNodeVersions(left: string, right: string): number;
+declare function isSupportedNodeVersion(nodeVersion?: string, minimumNodeVersion?: string): boolean;
+interface UnsupportedNodeVersionMessageOptions {
+    /**
+     * What is being refused, in the user's terms — "Haven setup", "The Haven
+     * signer". Leads the message so the reader knows what just stopped.
+     */
+    subject: string;
+    nodeVersion?: string;
+    minimumNodeVersion?: string;
+    /** Appended verbatim as the closing line. Used for the re-run instruction. */
+    retryHint?: string;
+}
+/**
+ * The refusal text.
+ *
+ * Names the detected version, the required version, and **how to fix it** — the
+ * previous message stopped after the two version numbers, which tells a user
+ * they are stuck without telling them how to get unstuck. The version-manager
+ * lines are the fix for nearly everyone; the closing caveat is there because the
+ * runtime that *spawns* the signer is frequently not the shell that was
+ * upgraded, and a desktop app can keep launching the old Node long after
+ * `node -v` in a terminal says otherwise.
+ */
+declare function unsupportedNodeVersionMessage(options: UnsupportedNodeVersionMessageOptions): string;
+
 /**
  * x402 protocol support for the Haven SDK.
  *
@@ -1501,6 +1773,36 @@ declare const SKILL_FOLDER_NAME = "haven-pay";
  * (see client.ts) since they need API access and signing.
  */
 
+/**
+ * Upper bound on the MERCHANT-requested part of the EIP-3009 authorization
+ * window (#715, epic #713). The x402 library sets
+ * `validBefore = now + maxTimeoutSeconds` straight from the MERCHANT's 402
+ * challenge — without a cap, a malicious or sloppy merchant can request a
+ * year-long window and a leaked signed authorization stays spendable that
+ * whole time. 600 s is generous for any facilitator settle (typical is
+ * 30–60 s); we CLAMP rather than reject so payments keep flowing while
+ * exposure stays bounded. `validBefore` is a deadline, not a demand —
+ * settling earlier is always valid.
+ */
+declare const X402_MAX_AUTHORIZATION_WINDOW_SECONDS = 600;
+/**
+ * Forward margin ADDED on top of the (clamped) merchant timeout when the
+ * authorization is actually signed (#1256). The x402 verify rule requires
+ * `validBefore ≥ now + maxTimeoutSeconds` AT THE FACILITATOR — but the
+ * upstream library computes `validBefore = now + maxTimeoutSeconds` at
+ * SIGNING time, leaving zero forward margin. Haven's flow guarantees elapsed
+ * time between the two (the funding UserOp confirms before the merchant
+ * retry, ~1 min plus latency), so every purchase against a merchant whose
+ * `maxTimeoutSeconds` exceeded that latency failed structurally — measured
+ * live on Base mainnet: Anchor requires 300 s, and 226 s remained at verify.
+ *
+ * 300 s covers funding + retry latency with room to spare. The #715 exposure
+ * ceiling becomes clamped-timeout + margin ≤ 900 s total forward — a
+ * deliberate widening from 600 s, recorded on #1256: an authorization that
+ * cannot pass verify protects no one, and 900 s is still bounded by the same
+ * clamp discipline.
+ */
+declare const X402_SETTLEMENT_FORWARD_MARGIN_SECONDS = 300;
 /**
  * Parse an HTTP 402 response into x402 PaymentRequired data.
  *
@@ -1534,6 +1836,22 @@ declare function selectPaymentOption(accepts: X402PaymentOption[]): X402PaymentO
  */
 declare function selectStandardPaymentOption(accepts: X402PaymentOption[]): X402PaymentOption | null;
 declare function x402AuthorizationAmount(option: X402PaymentOption): string;
+/**
+ * Canonical Haven-authenticated x402 expected context, recomputed byte-for-byte
+ * by the edge signer before it signs anything.
+ *
+ * **Two versions, and the version is derived — never passed in (#1138).**
+ * `typedDataHash` present ⇒ v2, absent ⇒ v1. A v1 message is byte-identical to
+ * what shipped before, so existing signers keep verifying legacy-rail bindings
+ * unchanged.
+ *
+ * The version lives in both the header line and the payload so neither can be
+ * reinterpreted as the other: a v2 context cannot be replayed as a v1 one that
+ * drops the typed-data commitment, and a v1 context cannot be presented as v2.
+ * That downgrade is exactly the attack the digest exists to stop — see
+ * `assertExpectedBinding` in `@haven_ai/signer`, which refuses to raw-sign a
+ * hash under a v2 binding and refuses to sign typed data without one.
+ */
 declare function buildX402ExpectedMessage(context: X402ExpectedContext): string;
 declare function toStandardPaymentRequirements(paymentRequired: X402PaymentRequired, option: X402PaymentOption): PaymentRequirements;
 /**
@@ -1597,4 +1915,4 @@ declare function encodeBase64Json(value: unknown): string;
  */
 declare function decodeBase64Json<T>(value: string, label?: string): T;
 
-export { AGENT_PAYMENT_FAILURE_CODE_VALUES, AGENT_PAYMENT_NEXT_ACTION_VALUES, AGENT_PAYMENT_PHASE_VALUES, AGENT_PAYMENT_RAIL_VALUES, type AgentPaymentEnumSchema, AgentPaymentFailureCode, AgentPaymentFailureCodeDescriptions, AgentPaymentFailureCodeSchema, AgentPaymentNextAction, AgentPaymentNextActionDescriptions, AgentPaymentNextActionSchema, AgentPaymentPhase, AgentPaymentPhaseDescriptions, AgentPaymentPhaseSchema, AgentPaymentRail, AgentPaymentRailDescriptions, AgentPaymentRailSchema, type ClaudeTool, HAVEN_SKILL_MD, type HavenAgent, type HavenAgentAllowanceSummary, type HavenAgentReadiness, type HavenAgentSummary, type HavenAllowance, type HavenAllowanceSummary, HavenApiError, type HavenCatalogEntry, HavenClient, type HavenClientConfig, HavenError, type HavenPaymentReceipt, HavenPaymentStateError, HavenSigningError, HavenTimeoutError, type MachinePaymentChallenge, type MachinePaymentRail, type MachinePaymentReceipt, type MppAuthorizationOptions, type MppQuote, type MppResumeState, type OpenAITool, type PaymentIntent, type PaymentNextAction, type PaymentPhase, type PaymentRequest, type PaymentResult, type PaymentResumeState, type PaymentStatus, type PaymentStatusResult, type PendingApproval, type ResumeAuthorizedMppInput, type ResumeAuthorizedX402Input, type ResumeMppPaymentInput, type ResumeX402PaymentInput, SKILL_FOLDER_NAME, SWEEP_BASE_CHAIN_ID, SWEEP_BASE_USDC_ADDRESS, type SharedToolKey, type SignData, type SweepAuthorization, type SweepEip712Domain, type SweepEntry, type SweepExpectedAuth, type SweepPreparation, type SweepPrepareResponse, type SweepResult, type SweepSubmitResponse, type SweepSubmitResult, type SweepTypedData, TRANSFER_WITH_AUTHORIZATION_TYPES, type ToolDescription, type X402AuthorizationOptions, type X402ExpectedAuth, type X402ExpectedContext, type X402Intent, type X402McpTransport, type X402PaymentOption, type X402PaymentRequired, type X402Quote, type X402Receipt, type X402RequestSnapshot, type X402ResumeState, addressFromKey, buildMachinePaymentIdempotencyKey, buildSweepAuthorizationMessage, buildSweepTypedData, buildX402ExpectedMessage, composeDescription, decodeBase64Json, decodeBase64Utf8, encodeBase64Json, encodeBase64Utf8, encodeMachinePaymentProof, encodePaymentProof, havenTools, parseMachinePaymentChallenge, parseMachinePaymentChallengeResponse, parsePaymentRequired, parsePaymentRequiredResponse, selectPaymentOption, selectStandardPaymentOption, signHash, sweepUsdcAddress, sweepUsdcDomain, toStandardPaymentRequirements, toolDescriptions, verifySignature, x402AuthorizationAmount };
+export { AGENT_PAYMENT_FAILURE_CODE_VALUES, AGENT_PAYMENT_NEXT_ACTION_VALUES, AGENT_PAYMENT_PHASE_VALUES, AGENT_PAYMENT_RAIL_VALUES, type AgentPaymentEnumSchema, AgentPaymentFailureCode, AgentPaymentFailureCodeDescriptions, AgentPaymentFailureCodeSchema, AgentPaymentNextAction, AgentPaymentNextActionDescriptions, AgentPaymentNextActionSchema, AgentPaymentPhase, AgentPaymentPhaseDescriptions, AgentPaymentPhaseSchema, AgentPaymentRail, AgentPaymentRailDescriptions, AgentPaymentRailSchema, type ClaudeTool, HAVEN_MINIMUM_NODE_VERSION, HAVEN_SKILL_MD, type HavenAgent, type HavenAgentAllowanceSummary, type HavenAgentReadiness, type HavenAgentSummary, type HavenAllowance, type HavenAllowanceSummary, HavenApiError, type HavenCatalogEntry, HavenClient, type HavenClientConfig, HavenError, type HavenPaymentReceipt, HavenPaymentStateError, HavenSigningError, HavenTimeoutError, type MachinePaymentChallenge, type MachinePaymentRail, type MachinePaymentReceipt, type MppAuthorizationOptions, type MppQuote, type MppResumeState, type OpenAITool, type PaymentFee, type PaymentIntent, type PaymentNextAction, type PaymentPhase, type PaymentReceipt, type PaymentRequest, type PaymentResult, type PaymentResumeState, type PaymentStatus, type PaymentStatusResult, type PendingApproval, RECEIPT_VERSION, type ReceiptVerification, type ResumeAuthorizedMppInput, type ResumeAuthorizedX402Input, type ResumeMppPaymentInput, type ResumeX402PaymentInput, SKILL_FOLDER_NAME, SWEEP_BASE_CHAIN_ID, SWEEP_BASE_SEPOLIA_CHAIN_ID, SWEEP_BASE_SEPOLIA_USDC_ADDRESS, SWEEP_BASE_USDC_ADDRESS, type SharedToolKey, type SignData, type SweepAuthorization, type SweepEip712Domain, type SweepEntry, type SweepExpectedAuth, type SweepPreparation, type SweepPrepareResponse, type SweepResult, type SweepSubmitResponse, type SweepSubmitResult, type SweepTypedData, TRANSFER_WITH_AUTHORIZATION_TYPES, type ToolDescription, type UnsupportedNodeVersionMessageOptions, type X402AuthorizationOptions, type X402ExpectedAuth, type X402ExpectedContext, type X402Intent, type X402McpTransport, type X402PaymentOption, type X402PaymentRequired, type X402Quote, type X402Receipt, type X402RequestSnapshot, type X402ResumeState, X402_MAX_AUTHORIZATION_WINDOW_SECONDS, X402_SETTLEMENT_FORWARD_MARGIN_SECONDS, addressFromKey, buildMachinePaymentIdempotencyKey, buildSweepAuthorizationMessage, buildSweepTypedData, buildX402ExpectedMessage, compareNodeVersions, composeDescription, decodeBase64Json, decodeBase64Utf8, encodeBase64Json, encodeBase64Utf8, encodeMachinePaymentProof, encodePaymentProof, havenTools, isSupportedNodeVersion, isSweepableChain, parseMachinePaymentChallenge, parseMachinePaymentChallengeResponse, parsePaymentRequired, parsePaymentRequiredResponse, selectPaymentOption, selectStandardPaymentOption, signHash, signUserOpTypedDataForDelegation, sweepUsdcAddress, sweepUsdcDomain, toStandardPaymentRequirements, toolDescriptions, unsupportedNodeVersionMessage, verifyPaymentReceipt, verifySignature, x402AuthorizationAmount };