@absol-labs/agent 0.8.0 → 0.9.1

package/src/frameworks/agentkit.ts

@@ -14,12 +14,14 @@ import { isAddress, isHex } from "viem";
 import { z } from "zod";
 
 import {
+  RegistryUnavailableError,
   discoverServices as defaultDiscoverServices,
   type DiscoverServicesOptions,
   type ServiceListing,
 } from "../discovery/registry.js";
 import { checkMandate, type SignedSpendMandate } from "../mandates/mandate.js";
 import {
+  isCheckpointStream,
   MandateDeniedError,
   VerifiedStreamAgentClient,
   type AgentSdkClientFactory,
@@ -281,12 +283,30 @@ export class MetrikActionProvider extends ActionProvider<WalletProvider> {
     _walletProvider: WalletProvider,
     args: z.infer<typeof discoverServicesSchema>,
   ): Promise<string> {
-    const listings = await this.#discover({
-      ...(args.category === undefined ? {} : { category: args.category }),
-      ...(args.limit === undefined ? {} : { limit: args.limit }),
-    });
+    let listings: ServiceListing[];
+    try {
+      listings = await this.#discover({
+        ...(args.category === undefined ? {} : { category: args.category }),
+        ...(args.limit === undefined ? {} : { limit: args.limit }),
+      });
+    } catch (error) {
+      // Discovery throws when the registry could not be READ at all. Every other
+      // action here returns a string, and more importantly an agent must be able to
+      // tell "the marketplace was never reached" from "the marketplace is empty" —
+      // collapsing them is how an agent concludes there is nothing to hire and gives
+      // up on a live marketplace. So report the failure as a failure, explicitly.
+      if (error instanceof RegistryUnavailableError) {
+        return (
+          "Could not reach the Metrik marketplace registry, so the set of available " +
+          "services is UNKNOWN — this is not the same as there being no services. " +
+          `Do not conclude nothing is hireable. Reason: ${error.message}`
+        );
+      }
+      throw error;
+    }
     if (listings.length === 0) {
-      return "No verified Metrik services discovered.";
+      // Reachable and genuinely empty, or everything filtered out — a real answer.
+      return "No verified Metrik services discovered (the registry was reachable and returned no listing that passed verification).";
     }
     const lines = listings.map(
       (listing) =>
@@ -381,9 +401,13 @@ export class MetrikActionProvider extends ActionProvider<WalletProvider> {
 
     return (
       `Stream ${streamId} is ${stream.status}${paused ? " (payment halted)" : ""}. ` +
-      `Verified accrued: ${formatUsdc(stream.accrued)} USDC of ${formatUsdc(stream.deposit)} deposited. ` +
-      `Claimable by seller: ${formatUsdc(claimable)} USDC. Reclaimable by buyer: ${formatUsdc(reclaimable)} USDC. ` +
-      `Consecutive failed checks: ${stream.consecutiveFailures}.`
+      (isCheckpointStream(stream)
+        ? `Verified entitlement: ${formatUsdc(stream.settledCumulative)} USDC of ` +
+          `${formatUsdc(stream.deposit)} deposited, of which ` +
+          `${formatUsdc(stream.claimedCumulative)} USDC has been claimed. `
+        : `Verified accrued: ${formatUsdc(stream.accrued)} USDC of ` +
+          `${formatUsdc(stream.deposit)} deposited. `) +
+      `Claimable by seller: ${formatUsdc(claimable)} USDC. Reclaimable by buyer: ${formatUsdc(reclaimable)} USDC.`
     );
   }
 

package/src/frameworks/eliza.ts

@@ -15,6 +15,7 @@ import {
 } from "../discovery/registry.js";
 import { checkMandate, type SignedSpendMandate } from "../mandates/mandate.js";
 import {
+  isCheckpointStream,
   type MandateAuthorizedStreamActionInput,
   type ReclaimAuthorizedStreamInput,
   type ReclaimVerifiedStreamResult,
@@ -733,9 +734,19 @@ function serializeStreamStatus(
       ...result.stream,
       deposit: result.stream.deposit.toString(),
       ratePerSecond: result.stream.ratePerSecond.toString(),
-      accrued: result.stream.accrued.toString(),
-      claimed: result.stream.claimed.toString(),
-      lastSequence: result.stream.lastSequence.toString(),
+      // The two escrow generations report entitlement differently; emit the
+      // vocabulary of whichever one answered rather than inventing a shared one.
+      ...(isCheckpointStream(result.stream)
+        ? {
+            settledCumulative: result.stream.settledCumulative.toString(),
+            claimedCumulative: result.stream.claimedCumulative.toString(),
+            feesPaid: result.stream.feesPaid.toString(),
+          }
+        : {
+            accrued: result.stream.accrued.toString(),
+            claimed: result.stream.claimed.toString(),
+            lastSequence: result.stream.lastSequence.toString(),
+          }),
     },
     claimable: result.claimable.toString(),
     reclaimable: result.reclaimable.toString(),

package/src/frameworks/langchain.ts

@@ -9,6 +9,7 @@ import {
 } from "../discovery/registry.js";
 import { checkMandate, type SignedSpendMandate } from "../mandates/mandate.js";
 import {
+  isCheckpointStream,
   type MandateAuthorizedStreamActionInput,
   type ReclaimAuthorizedStreamInput,
   type ReclaimVerifiedStreamResult,
@@ -332,9 +333,19 @@ function serializeStreamStatus(
       ...result.stream,
       deposit: result.stream.deposit.toString(),
       ratePerSecond: result.stream.ratePerSecond.toString(),
-      accrued: result.stream.accrued.toString(),
-      claimed: result.stream.claimed.toString(),
-      lastSequence: result.stream.lastSequence.toString(),
+      // The two escrow generations report entitlement differently; emit the
+      // vocabulary of whichever one answered rather than inventing a shared one.
+      ...(isCheckpointStream(result.stream)
+        ? {
+            settledCumulative: result.stream.settledCumulative.toString(),
+            claimedCumulative: result.stream.claimedCumulative.toString(),
+            feesPaid: result.stream.feesPaid.toString(),
+          }
+        : {
+            accrued: result.stream.accrued.toString(),
+            claimed: result.stream.claimed.toString(),
+            lastSequence: result.stream.lastSequence.toString(),
+          }),
     },
     claimable: result.claimable.toString(),
     reclaimable: result.reclaimable.toString(),

package/src/index.ts

@@ -46,13 +46,18 @@ export {
 } from "./x402/facilitator.js";
 
 export {
+  DEFAULT_METRIK_PUBLIC_REGISTRY_URL,
   DEFAULT_METRIK_REGISTRY_URL,
   DEMO_SEED_LISTING,
   DEMO_SEED_SERVICE_REF,
   LIVE_DATA_SEED_LISTING,
   LIVE_DATA_SEED_SERVICE_REF,
+  RegistryUnavailableError,
   discoverServices,
+  discoverServicesDetailed,
+  type DiscoverResult,
   type DiscoverServicesOptions,
+  type DiscoveredService,
   type ServiceListing,
 } from "./discovery/registry.js";
 
@@ -99,6 +104,8 @@ export {
   type ReclaimAuthorizedStreamInput,
   type ReclaimVerifiedStreamOptions,
   type ReclaimVerifiedStreamResult,
+  isCheckpointStream,
+  type StreamStatusStream,
   type StreamStatusView,
   type VerifiedStreamAgentOpener,
 } from "./sdk/client.js";

package/src/mcp/server.ts

@@ -20,6 +20,7 @@ import {
   ServerMandateConfigError,
 } from "../mandates/env.js";
 import {
+  isCheckpointStream,
   VerifiedStreamAgentClient,
   type ReclaimAuthorizedStreamInput,
   type ReclaimVerifiedStreamResult,
@@ -859,6 +860,11 @@ export async function createVerifiedStreamMcpServerOptionsFromEnv(
       chain: parsed.chain,
       transport: http(parsed.rpcUrl),
       escrow: parsed.escrow,
+      // Declare the escrow as V2 as well. Without this the SDK treats the
+      // client as V1 and routes claimable()/reclaimable() to the legacy ABI,
+      // which reverts against StreamEscrowV2 — the checkpoint escrow replaced
+      // those one-argument views with proof-carrying ones.
+      escrowV2: parsed.escrow,
       usdc: parsed.usdc,
       settlementTarget: {
         chainId: parsed.chain.id,
@@ -943,15 +949,30 @@ function serializeStreamStatus(
       operator: status.stream.operator,
       serviceRef: status.stream.serviceRef,
       deposit: status.stream.deposit.toString(),
+      // Informational on a checkpoint escrow: it stores the rate but computes
+      // no accrual. Emit the vocabulary of whichever escrow generation answered
+      // instead of flattening two incompatible tuples into one shape.
       ratePerSecond: status.stream.ratePerSecond.toString(),
-      accrued: status.stream.accrued.toString(),
-      claimed: status.stream.claimed.toString(),
       openedAt: status.stream.openedAt,
       expiresAt: status.stream.expiresAt,
-      lastVerifiedAt: status.stream.lastVerifiedAt,
-      lastSequence: status.stream.lastSequence.toString(),
-      consecutiveFailures: status.stream.consecutiveFailures,
       status: status.stream.status,
+      ...(isCheckpointStream(status.stream)
+        ? {
+            settlement: "checkpoint" as const,
+            settledCumulative: status.stream.settledCumulative.toString(),
+            claimedCumulative: status.stream.claimedCumulative.toString(),
+            feesPaid: status.stream.feesPaid.toString(),
+            closedAt: status.stream.closedAt,
+            reclaimed: status.stream.reclaimed,
+          }
+        : {
+            settlement: "per-attestation" as const,
+            accrued: status.stream.accrued.toString(),
+            claimed: status.stream.claimed.toString(),
+            lastVerifiedAt: status.stream.lastVerifiedAt,
+            lastSequence: status.stream.lastSequence.toString(),
+            consecutiveFailures: status.stream.consecutiveFailures,
+          }),
     },
     claimable: status.claimable.toString(),
     reclaimable: status.reclaimable.toString(),

package/src/sdk/client.ts

@@ -3,6 +3,7 @@ import {
   type HireComputeResult,
   type StreamProofClientConfig,
   type StreamProofStream,
+  type StreamV2,
 } from "@absol-labs/sdk";
 
 import {
@@ -25,8 +26,23 @@ export interface OpenVerifiedStreamInput {
   readonly revokedMandateIds?: Iterable<`0x${string}`>;
 }
 
+/**
+ * A stream as read from the configured escrow. Checkpoint escrows (V2) and the
+ * legacy per-attestation escrow (V1) expose incompatible tuples, so the view
+ * carries whichever one the client is pointed at. Narrow with
+ * {@link isCheckpointStream} before touching version-specific fields.
+ */
+export type StreamStatusStream = StreamProofStream | StreamV2;
+
+/** True when the stream came from a checkpoint-settled (V2) escrow. */
+export function isCheckpointStream(
+  stream: StreamStatusStream,
+): stream is StreamV2 {
+  return "settledCumulative" in stream;
+}
+
 export interface StreamStatusView {
-  readonly stream: StreamProofStream;
+  readonly stream: StreamStatusStream;
   readonly claimable: bigint;
   readonly reclaimable: bigint;
 }
@@ -63,7 +79,11 @@ export interface AgentSdkClient {
     readonly ratePerSecond: bigint;
     readonly maxDurationSeconds: number;
   }): Promise<HireComputeResult>;
+  // Both decoders. The SDK deliberately makes `getStream` throw once a V2
+  // escrow is configured (the tuples are incompatible), so the caller must pick
+  // based on configuration rather than probing.
   getStream(streamId: `0x${string}`): Promise<StreamProofStream>;
+  getStreamV2(streamId: `0x${string}`): Promise<StreamV2>;
   claimable(streamId: `0x${string}`): Promise<bigint>;
   reclaimable(streamId: `0x${string}`): Promise<bigint>;
   claim(streamId: `0x${string}`): Promise<StreamProofTransactionResult>;
@@ -93,6 +113,12 @@ export class MandateDeniedError extends Error {
 
 export class VerifiedStreamAgentClient implements VerifiedStreamAgentOpener {
   private readonly sdkClient: AgentSdkClient;
+  /**
+   * Whether the configured escrow is checkpoint-settled. Set once from config:
+   * the SDK throws rather than guessing if the wrong decoder is used, so this
+   * has to be decided here instead of discovered by trial.
+   */
+  private readonly checkpointSettled: boolean;
 
   constructor(
     config: StreamProofClientConfig,
@@ -101,6 +127,15 @@ export class VerifiedStreamAgentClient implements VerifiedStreamAgentOpener {
     this.sdkClient = (options.createSdkClient ?? defaultSdkClientFactory)(
       config,
     );
+    this.checkpointSettled = config.escrowV2 !== undefined;
+  }
+
+  private async readStream(
+    streamId: `0x${string}`,
+  ): Promise<StreamStatusStream> {
+    return this.checkpointSettled
+      ? await this.sdkClient.getStreamV2(streamId)
+      : await this.sdkClient.getStream(streamId);
   }
 
   async openVerifiedStream(
@@ -132,7 +167,7 @@ export class VerifiedStreamAgentClient implements VerifiedStreamAgentOpener {
 
   async getStreamStatus(streamId: `0x${string}`): Promise<StreamStatusView> {
     const [stream, claimable, reclaimable] = await Promise.all([
-      this.sdkClient.getStream(streamId),
+      this.readStream(streamId),
       this.sdkClient.claimable(streamId),
       this.sdkClient.reclaimable(streamId),
     ]);
@@ -183,7 +218,7 @@ export class VerifiedStreamAgentClient implements VerifiedStreamAgentOpener {
   private async authorizeExistingStreamAction(
     input: MandateAuthorizedStreamActionInput,
   ): Promise<void> {
-    const stream = await this.sdkClient.getStream(input.streamId);
+    const stream = await this.readStream(input.streamId);
     const decision = await checkMandate(
       input.signedMandate,
       {

package/src/wallet/cdp-sdk.ts

@@ -0,0 +1,33 @@
+/**
+ * `@coinbase/cdp-sdk` is an OPTIONAL peer dependency: only consumers that use the
+ * Coinbase CDP wallet path need it, and it carries a very large transitive graph
+ * (it was the main contributor to the 18 -> ~515 package jump a consumer saw just
+ * for hiring and invoking a service). The top-level "@absol-labs/agent" barrel
+ * DOES reach `./provider.ts`, so that module must import the SDK's TYPES only
+ * (`import type`, erased at compile time) and load the runtime module lazily
+ * through this loader at the point of first use.
+ *
+ * This is the same contract as `../zktls/reclaim-js-sdk.ts`, and it is enforced
+ * by the barrel-reachability guard in `test/flat-install.test.ts`: a static value
+ * import of an optional peer from any barrel-reachable module fails that test.
+ *
+ * Deliberately NOT a top-level `await import(...)` (the pattern used by
+ * `../frameworks/agentkit.ts`): those modules are not barrel-reachable, this one
+ * is, and a top-level await would re-introduce the hard dependency at
+ * barrel-import time — precisely the regression that issue #79 was filed for.
+ */
+
+type CdpSdkModule = typeof import("@coinbase/cdp-sdk");
+
+let modulePromise: Promise<CdpSdkModule> | undefined;
+
+/** Memoized lazy load with an actionable missing-peer error. */
+export async function loadCdpSdk(): Promise<CdpSdkModule> {
+  modulePromise ??= import("@coinbase/cdp-sdk").catch((error: unknown) => {
+    throw new Error(
+      "@absol-labs/agent CDP wallet support requires the optional peer dependency '@coinbase/cdp-sdk'. Install it with `npm install @coinbase/cdp-sdk`, or use a different wallet mode (the autonomous Privy wallet and an injected account both work without it).",
+      { cause: error },
+    );
+  });
+  return await modulePromise;
+}

package/src/wallet/provider.ts

@@ -1,9 +1,10 @@
 import { type StreamProofClientConfig } from "@absol-labs/sdk";
-import {
-  CdpClient,
-  type EvmServerAccount,
-  type EvmSmartAccount,
-} from "@coinbase/cdp-sdk";
+// `@coinbase/cdp-sdk` is an OPTIONAL peer dependency: TYPES only here (erased at
+// compile time), the runtime module via `loadCdpSdk()` at the point of first use.
+// This module IS reachable from the package barrel, so a value import here would
+// re-introduce the hard dependency for every consumer. See ./cdp-sdk.ts.
+import type { EvmServerAccount, EvmSmartAccount } from "@coinbase/cdp-sdk";
+import { loadCdpSdk } from "./cdp-sdk.js";
 import {
   custom,
   toHex,
@@ -173,9 +174,12 @@ export async function resolveAgentWallet(
     };
   }
 
-  const cdpClient = (options.createCdpClient ?? defaultCdpClientFactory)(
-    input.cdp,
-  );
+  // An injected factory keeps its synchronous public signature; only the DEFAULT
+  // path is async, because it lazily loads the optional @coinbase/cdp-sdk peer.
+  const cdpClient =
+    options.createCdpClient === undefined
+      ? await defaultCdpClientFactory(input.cdp)
+      : options.createCdpClient(input.cdp);
   const owner = await cdpClient.evm.getOrCreateAccount({
     name: input.cdp.ownerName,
   });
@@ -338,7 +342,10 @@ export function parseAgentWalletEnv(
   };
 }
 
-function defaultCdpClientFactory(config: CdpWalletConfig): CdpClientLike {
+async function defaultCdpClientFactory(
+  config: CdpWalletConfig,
+): Promise<CdpClientLike> {
+  const { CdpClient } = await loadCdpSdk();
   return new CdpClient({
     ...(config.apiKeyId === undefined ? {} : { apiKeyId: config.apiKeyId }),
     ...(config.apiKeySecret === undefined

package/src/zktls/reclaim-js-sdk.ts

@@ -0,0 +1,50 @@
+/**
+ * `@reclaimprotocol/js-sdk` is an OPTIONAL peer dependency: only consumers that
+ * actually generate/verify zkTLS delivery proofs (T2, issue #24) need it, and it
+ * carries a large transitive graph. The top-level "@absol-labs/agent" barrel
+ * DOES re-export the zkTLS modules, so those modules must import the SDK's
+ * TYPES only (`import type`, erased at compile time) and load the runtime module
+ * lazily through this loader at the point of first use.
+ *
+ * Deliberately NOT a top-level `await import(...)` (the pattern used by
+ * `../frameworks/langchain.ts`): that module is not barrel-reachable, this one
+ * is, and a top-level await would re-introduce the hard dependency at
+ * barrel-import time.
+ */
+
+type ReclaimJsSdkModule = typeof import("@reclaimprotocol/js-sdk");
+
+let modulePromise: Promise<ReclaimJsSdkModule> | undefined;
+
+/** Memoized lazy load with an actionable missing-peer error. */
+export async function loadReclaimJsSdk(): Promise<ReclaimJsSdkModule> {
+  modulePromise ??= import("@reclaimprotocol/js-sdk").catch(
+    (error: unknown) => {
+      throw new Error(
+        "@absol-labs/agent zkTLS delivery-proof support requires the optional peer dependency '@reclaimprotocol/js-sdk'. Install it with `npm install @reclaimprotocol/js-sdk`.",
+        { cause: error },
+      );
+    },
+  );
+  return await modulePromise;
+}
+
+/**
+ * `@reclaimprotocol/zk-fetch` is the companion optional peer used to PRODUCE
+ * proofs (the SDK above verifies them). Same contract, same actionable error.
+ */
+type ReclaimZkFetchModule = typeof import("@reclaimprotocol/zk-fetch");
+
+let zkFetchModulePromise: Promise<ReclaimZkFetchModule> | undefined;
+
+export async function loadReclaimZkFetch(): Promise<ReclaimZkFetchModule> {
+  zkFetchModulePromise ??= import("@reclaimprotocol/zk-fetch").catch(
+    (error: unknown) => {
+      throw new Error(
+        "@absol-labs/agent zkTLS delivery-proof support requires the optional peer dependency '@reclaimprotocol/zk-fetch'. Install it with `npm install @reclaimprotocol/zk-fetch`.",
+        { cause: error },
+      );
+    },
+  );
+  return await zkFetchModulePromise;
+}

package/src/zktls/reclaim.ts

@@ -1,13 +1,16 @@
-import {
-  getHttpProviderClaimParamsFromProof,
-  getProviderHashRequirementsFromSpec,
+// `@reclaimprotocol/js-sdk` is an OPTIONAL peer dependency: TYPES only here
+// (erased at compile time), runtime values via `loadReclaimJsSdk()` at the point
+// of first use. See ./reclaim-js-sdk.ts.
+import type {
   verifyProof,
-  type Proof as ReclaimProtocolProof,
-  type RequestSpec,
-  type VerifyProofResult,
+  Proof as ReclaimProtocolProof,
+  RequestSpec,
+  VerifyProofResult,
 } from "@reclaimprotocol/js-sdk";
 import { z } from "zod";
 
+import { loadReclaimJsSdk, loadReclaimZkFetch } from "./reclaim-js-sdk.js";
+
 const addressSchema = z.string().regex(/^0x[0-9a-fA-F]{40}$/);
 const bytes32Schema = z.string().regex(/^0x[0-9a-fA-F]{64}$/);
 const httpMethodSchema = z.enum(["GET", "POST", "PUT"]);
@@ -172,7 +175,14 @@ const reclaimProofInputSchema = z.object({
 export class ReclaimConsumerProofService implements ConsumerDeliveryProofService {
   private readonly client: ReclaimClientLike;
   private readonly config: ReclaimProofServiceConfig;
-  private readonly verifyProofImpl: VerifyProofFn;
+  /**
+   * Caller-supplied verifier, if any. NOT defaulted in the constructor: the real
+   * `verifyProof` lives in the optional peer `@reclaimprotocol/js-sdk`, which is
+   * loaded lazily at first use so that merely constructing this service — or
+   * importing the package barrel — never requires the peer to be installed.
+   * Resolved in {@link resolveVerifyProof}.
+   */
+  private readonly verifyProofOverride: VerifyProofFn | undefined;
 
   constructor(
     config: ReclaimProofServiceConfig,
@@ -194,7 +204,16 @@ export class ReclaimConsumerProofService implements ConsumerDeliveryProofService
       this.config.applicationSecret,
       this.config.logs ?? false,
     );
-    this.verifyProofImpl = options.verifyProof ?? verifyProof;
+    this.verifyProofOverride = options.verifyProof;
+  }
+
+  /**
+   * The verifier to use: a caller-supplied override, else the optional peer's
+   * `verifyProof`, loaded on first use with an actionable missing-peer error.
+   */
+  private async resolveVerifyProof(): Promise<VerifyProofFn> {
+    if (this.verifyProofOverride !== undefined) return this.verifyProofOverride;
+    return (await loadReclaimJsSdk()).verifyProof;
   }
 
   async proveConsumedHttpsResponse(
@@ -244,8 +263,15 @@ export class ReclaimConsumerProofService implements ConsumerDeliveryProofService
       );
     }
 
-    const verification = await this.verifyProofImpl(proof, {
-      ...getProviderHashRequirementsFromSpec({
+    // Both the verifier and the provider-hash helper live in the optional peer;
+    // load it once here rather than importing it at module scope.
+    const [verifyProofFn, reclaimSdk] = await Promise.all([
+      this.resolveVerifyProof(),
+      loadReclaimJsSdk(),
+    ]);
+
+    const verification = await verifyProofFn(proof, {
+      ...reclaimSdk.getProviderHashRequirementsFromSpec({
         requests: [toRequestSpec(parsed, method)],
       }),
       ...(parsed.useTee === true
@@ -271,25 +297,33 @@ export class ReclaimConsumerProofService implements ConsumerDeliveryProofService
       );
     }
 
-    const request = getHttpProviderClaimParamsFromProof(proof);
+    // Same optional peer, already memoized by the loader above.
+    const request = reclaimSdk.getHttpProviderClaimParamsFromProof(proof);
+    type ClaimParams = ReturnType<
+      typeof reclaimSdk.getHttpProviderClaimParamsFromProof
+    >;
     return {
       proof,
       request: {
         url: request.url,
         method: request.method as "GET" | "POST" | "PUT",
         body: request.body === "" ? null : (request.body ?? null),
-        responseMatches: request.responseMatches.map((match) => ({
-          value: match.value,
-          type: match.type,
-          invert: match.invert,
-          isOptional: match.isOptional,
-        })),
-        responseRedactions: request.responseRedactions.map((redaction) => ({
-          regex: redaction.regex,
-          jsonPath: redaction.jsonPath,
-          xPath: redaction.xPath,
-          hash: redaction.hash,
-        })),
+        responseMatches: request.responseMatches.map(
+          (match: ClaimParams["responseMatches"][number]) => ({
+            value: match.value,
+            type: match.type,
+            invert: match.invert,
+            isOptional: match.isOptional,
+          }),
+        ),
+        responseRedactions: request.responseRedactions.map(
+          (redaction: ClaimParams["responseRedactions"][number]) => ({
+            regex: redaction.regex,
+            jsonPath: redaction.jsonPath,
+            xPath: redaction.xPath,
+            hash: redaction.hash,
+          }),
+        ),
       },
       verification: {
         context: trusted.context,

package/src/zktls/t2-delivery-proof.ts

@@ -5,11 +5,12 @@ import {
   type DeliveryReceipt,
   type DeliveryReceiptDomainInput,
 } from "@absol-labs/shared";
-import {
-  getHttpProviderClaimParamsFromProof,
-  getProviderHashRequirementsFromSpec,
-  verifyProof,
-} from "@reclaimprotocol/js-sdk";
+// `@reclaimprotocol/js-sdk` is an OPTIONAL peer dependency and this module IS
+// reachable from the package barrel, so it may import TYPES only (erased at
+// compile time); runtime values come from `loadReclaimJsSdk()` at first use.
+// Enforced by the barrel-reachability guard in test/flat-install.test.ts.
+import type { verifyProof } from "@reclaimprotocol/js-sdk";
+import { loadReclaimJsSdk } from "./reclaim-js-sdk.js";
 import {
   keccak256,
   stringToBytes,
@@ -167,7 +168,12 @@ const reclaimT2UrlSchema = z.string().url();
 export class ReclaimDeliveryProofAttestor implements DeliveryProofAttestor {
   private readonly client: ReclaimClientLike;
   private readonly config: ReclaimProofServiceConfig;
-  private readonly verifyProofImpl: VerifyProofFn;
+  /**
+   * Caller-supplied verifier, if any. NOT defaulted in the constructor: the real
+   * `verifyProof` lives in the optional peer, loaded lazily at first use so that
+   * constructing this service never requires the peer to be installed.
+   */
+  private readonly verifyProofOverride: VerifyProofFn | undefined;
 
   constructor(
     config: ReclaimProofServiceConfig,
@@ -189,7 +195,13 @@ export class ReclaimDeliveryProofAttestor implements DeliveryProofAttestor {
       this.config.applicationSecret,
       this.config.logs ?? false,
     );
-    this.verifyProofImpl = options.verifyProof ?? verifyProof;
+    this.verifyProofOverride = options.verifyProof;
+  }
+
+  /** Override if given, else the optional peer's `verifyProof`, loaded on demand. */
+  private async resolveVerifyProof(): Promise<VerifyProofFn> {
+    if (this.verifyProofOverride !== undefined) return this.verifyProofOverride;
+    return (await loadReclaimJsSdk()).verifyProof;
   }
 
   async proveDeliveryResponse(
@@ -245,8 +257,14 @@ export class ReclaimDeliveryProofAttestor implements DeliveryProofAttestor {
       );
     }
 
-    const verification = await this.verifyProofImpl(proof, {
-      ...getProviderHashRequirementsFromSpec({
+    // Verifier and provider-hash helper both live in the optional peer; load once.
+    const [verifyProofFn, reclaimSdk] = await Promise.all([
+      this.resolveVerifyProof(),
+      loadReclaimJsSdk(),
+    ]);
+
+    const verification = await verifyProofFn(proof, {
+      ...reclaimSdk.getProviderHashRequirementsFromSpec({
         requests: [toRequestSpec(parsed, method)],
       }),
       ...(parsed.useTee === true
@@ -266,7 +284,7 @@ export class ReclaimDeliveryProofAttestor implements DeliveryProofAttestor {
       );
     }
 
-    const request = getHttpProviderClaimParamsFromProof(proof);
+    const request = reclaimSdk.getHttpProviderClaimParamsFromProof(proof);
     return {
       proof,
       request: {