@absol-labs/agent 0.8.0 → 0.9.0

package/src/frameworks/agentkit.ts

@@ -14,6 +14,7 @@ import { isAddress, isHex } from "viem";
 import { z } from "zod";
 
 import {
+  RegistryUnavailableError,
   discoverServices as defaultDiscoverServices,
   type DiscoverServicesOptions,
   type ServiceListing,
@@ -281,12 +282,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) =>

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";
 

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: {