@absol-labs/agent 0.10.0 → 0.12.0-rc.1

package/src/cli/commands/mcp.ts

@@ -1,6 +1,6 @@
 import { booleanFlag, stringFlag } from "../args.js";
 import { packageVersion } from "../version.js";
-import { CDP_ENV_VARS, PRIVATE_KEY_ENV } from "../wallet.js";
+import { CDP_ENV_VARS, PRIVATE_KEY_ENV, PRIVY_ENV_VARS } from "../wallet.js";
 import type { CommandContext, CommandSpec } from "../context.js";
 
 /** The published executable an MCP host starts. Declared in `package.json#bin`. */
@@ -82,6 +82,17 @@ export const mcpCommand: CommandSpec = {
       },
     };
 
+    // Honesty about the one wallet source this block cannot carry. The CLI
+    // resolves a Privy wallet (step 3), but the MCP server's own resolver,
+    // `parseAgentWalletEnv()`, reads a raw key or CDP and nothing else — there
+    // is no Privy path from the environment there. Printing Privy variables
+    // into a config the server would ignore is the failure this says out loud.
+    if (PRIVY_ENV_VARS.some((variable) => (env[variable] ?? "").length > 0)) {
+      out.note(
+        `note: this environment configures a Privy wallet, which the CLI can use but \`${MCP_BIN}\` cannot — its wallet resolver reads ${PRIVATE_KEY_ENV} or the CDP variables only. The block below therefore carries a key placeholder; give the MCP server a raw key or a CDP account.`,
+      );
+    }
+
     out.result(document);
     out.print(
       `Paste this into your MCP client's config (Claude Desktop: claude_desktop_config.json), then replace every <…> placeholder:`,
@@ -102,6 +113,11 @@ export const mcpCommand: CommandSpec = {
  * Wallet variables, shaped to match how the environment running this command is
  * already configured — CDP if that is what is set, a raw key otherwise.
  *
+ * Privy is deliberately absent: `parseAgentWalletEnv()`, which is what the MCP
+ * server resolves its wallet with, has no Privy branch. A Privy block here
+ * would print a config that cannot start the server. The command says so on
+ * stderr instead.
+ *
  * Values are ALWAYS placeholders. `metrik` prints derived addresses and never
  * echoes a credential, and a config block is the single most likely thing to be
  * pasted into a chat window or an issue.
@@ -116,7 +132,7 @@ function walletEnv(env: NodeJS.ProcessEnv): Record<string, string> {
     );
   }
   return {
-    [PRIVATE_KEY_ENV]: "<0x… a funded Base Sepolia test key>",
+    [PRIVATE_KEY_ENV]: "<0x… a funded testnet key>",
   };
 }
 

package/src/cli/commands/open.ts

@@ -8,15 +8,27 @@ import {
   parseUsdcAmount,
 } from "../amounts.js";
 import { assertTestnetRpc, parseBytes32 } from "../config.js";
+import { writeClientOptions } from "../deps.js";
 import { CliError, configError } from "../errors.js";
+import type { PrivySpendPolicy } from "../privy.js";
+import {
+  assertWithinOperatorCaps,
+  assertWithinSpendPolicy,
+} from "../spend-policy.js";
 import { cliMandateCaps, signCliMandate } from "../mandate.js";
 import { assertCanFundStream, assertCanPayGas } from "../preflight.js";
 import {
+  isPolicyEnforced,
   optionalCliWallet,
   resolveCliWallet,
   PRIVATE_KEY_ENV,
 } from "../wallet.js";
-import { resolveListing } from "../listings.js";
+import { resolveListingRecord } from "../listings.js";
+import {
+  listingRateBand,
+  rateBandRefusal,
+  SignedRateBoundsError,
+} from "../../discovery/rate-band.js";
 import type { CommandContext, CommandSpec } from "../context.js";
 
 export const openCommand: CommandSpec = {
@@ -74,22 +86,29 @@ export const openCommand: CommandSpec = {
     // the intended call and says which parts (allowance, simulation, mandate
     // signature) could not be produced, rather than inventing them.
     const wallet = dryRun
-      ? await optionalCliWallet(env, { note: out.note })
-      : await resolveCliWallet(env, { note: out.note });
+      ? await optionalCliWallet(env, { note: out.note, rpcUrl: config.rpcUrl })
+      : await resolveCliWallet(env, { note: out.note, rpcUrl: config.rpcUrl });
     const account = wallet?.account ?? null;
     const read = deps.createReadClient(config);
     await assertTestnetRpc(config, () => read.getChainId());
     if (account !== null && !dryRun) {
       // Both balances, before anything is signed. Gas first: a wallet with no
       // ETH cannot send the approval that the USDC check exists to protect.
-      await assertCanPayGas(read, account.address);
-      await assertCanFundStream(read, account.address, budgetUsdc);
+      await assertCanPayGas(read, account.address, config.network);
+      await assertCanFundStream(
+        read,
+        account.address,
+        budgetUsdc,
+        config.network,
+      );
     }
 
     const operatorOverride = stringFlag(args, "operator");
-    const listing = await resolveListing(context, serviceRef, {
+    const resolution = await resolveListingRecord(context, serviceRef, {
       required: operatorOverride === undefined,
     });
+    const listing = resolution.listing;
+    await assertRateInSignedBand(context, resolution, ratePerSecondUsdc);
     const operator = (operatorOverride ?? listing?.operator) as
       | `0x${string}`
       | undefined;
@@ -101,16 +120,41 @@ export const openCommand: CommandSpec = {
     }
 
     const spend = { operator, budgetUsdc, ratePerSecondUsdc, durationSeconds };
+    const mandateCaps = cliMandateCaps(spend, env);
+
+    // A policy-enforced wallet (Privy) is capped by its broker, not by a
+    // mandate this process signs for itself. Read the REAL ceiling and hold it
+    // to that instead — see `../spend-policy.ts` for why that substitution is
+    // the stronger of the two, and why re-adding the self-signed mandate here
+    // would both weaken it and break the wallet outright.
+    const policy: PrivySpendPolicy | null =
+      wallet !== null && isPolicyEnforced(wallet)
+        ? await wallet.readSpendPolicy()
+        : null;
+    if (policy !== null && !dryRun) {
+      assertWithinSpendPolicy(policy, spend);
+      // The operator's own standing ceiling still applies, and may be TIGHTER
+      // than the broker's. Enforced here because no mandate is signed to carry
+      // it — "policy-enforced" retires the self-signed mandate, not the caps
+      // the operator deliberately configured.
+      if (mandateCaps.source === "env") {
+        assertWithinOperatorCaps(mandateCaps.caps, spend);
+      }
+    }
+
     const mandate =
-      account === null
+      account === null || policy !== null
         ? null
         : await signCliMandate(account, spend, {
             chainId: config.chainId,
             env,
           });
-    const mandateCaps = cliMandateCaps(spend, env);
 
-    const write = deps.createWriteClient(config, account);
+    const write = deps.createWriteClient(
+      config,
+      account,
+      writeClientOptions(wallet),
+    );
     const hire = {
       operator,
       serviceRef,
@@ -145,6 +189,19 @@ export const openCommand: CommandSpec = {
         durationSeconds,
         mandateSource: mandateCaps.source,
         mandateSigned: mandate !== null,
+        spendPolicy:
+          policy === null
+            ? null
+            : {
+                brokerUrl: policy.brokerUrl,
+                maxTotalUsdc: policy.maxTotalUsdc,
+                maxRatePerSecondUsdc: policy.maxRatePerSecondUsdc,
+                maxDurationSeconds: policy.maxDurationSeconds,
+                fits:
+                  budgetUsdc <= policy.maxTotalUsdc &&
+                  ratePerSecondUsdc <= policy.maxRatePerSecondUsdc &&
+                  durationSeconds <= policy.maxDurationSeconds,
+              },
         to: preview.to,
         data: preview.data,
         chainId: preview.chainId,
@@ -180,10 +237,28 @@ export const openCommand: CommandSpec = {
         ["duration", formatDuration(durationSeconds)],
         [
           "mandate",
-          mandate === null
-            ? `not signed (no wallet); caps would come from ${mandateCaps.source}`
-            : `self-signed, caps from ${mandateCaps.source}`,
+          mandate !== null
+            ? `self-signed, caps from ${mandateCaps.source}`
+            : policy !== null
+              ? "not signed — this wallet's ceiling is enforced by its broker, which is stronger"
+              : `not signed (no wallet); caps would come from ${mandateCaps.source}`,
         ],
+        ...(policy === null
+          ? []
+          : ([
+              [
+                "spend policy",
+                `${formatUsdc(policy.maxTotalUsdc)} total, ${policy.maxRatePerSecondUsdc} atomic/second, ${formatDuration(policy.maxDurationSeconds)} max — enforced by ${policy.brokerUrl}`,
+              ],
+              [
+                "fits policy",
+                budgetUsdc <= policy.maxTotalUsdc &&
+                ratePerSecondUsdc <= policy.maxRatePerSecondUsdc &&
+                durationSeconds <= policy.maxDurationSeconds
+                  ? "yes"
+                  : "NO — a real open would be refused before broadcasting",
+              ],
+            ] as [string, string][])),
         ["escrow", preview.to],
         [
           "usdc balance",
@@ -219,7 +294,7 @@ export const openCommand: CommandSpec = {
     );
     // Unreachable without a wallet: `resolveCliWallet` above throws when the
     // command is not a dry run. The narrowing keeps that a type-level fact.
-    if (account === null || mandate === null) {
+    if (account === null) {
       throw configError(
         "this command signs a transaction and needs a wallet, and none was resolved",
       );
@@ -233,7 +308,10 @@ export const openCommand: CommandSpec = {
         budgetUsdc,
         ratePerSecondUsdc,
         maxDurationSeconds: durationSeconds,
-        signedMandate: mandate.signed,
+        // `null` for a policy-enforced wallet: the ceiling was checked against
+        // the broker's own policy above, and the broker checks it again on the
+        // transaction it signs.
+        signedMandate: mandate === null ? null : mandate.signed,
         spentSoFarUsdc: 0n,
         nowSeconds: deps.nowSeconds(),
       });
@@ -282,6 +360,65 @@ export const openCommand: CommandSpec = {
   },
 };
 
+/**
+ * Refuse a `--rate` outside the band the operator SIGNED, before anything is
+ * signed or broadcast — dry run included, because the rate is an invalid input
+ * for this service exactly like `--rate 0` is.
+ *
+ * The escrow accepts any non-zero rate; the seller's capability gateway does
+ * not, and answers every request on an out-of-band stream with
+ * `403 stream-rate-out-of-bounds`. Without this check the CLI locked a buyer's
+ * deposit in a stream that could never be served, and said nothing.
+ *
+ * - Listing found: its signed descriptor is re-verified and the band enforced.
+ *   A descriptor that does not verify is a refusal (exit 4), never "no band".
+ *   A legacy binding signs no commercial terms, so there is nothing to enforce.
+ * - No listing: only reachable with `--operator`, the CLI's existing,
+ *   explicit escape hatch for a service the registry cannot vouch for. The
+ *   check cannot run, so it is skipped LOUDLY rather than silently. Without
+ *   `--operator` an unreachable registry or a missing listing has already
+ *   failed the command before this point (`resolveListingRecord`).
+ */
+async function assertRateInSignedBand(
+  context: CommandContext,
+  resolution: Awaited<ReturnType<typeof resolveListingRecord>>,
+  ratePerSecondUsdc: bigint,
+): Promise<void> {
+  const { out } = context;
+  if (resolution.record === null) {
+    out.note(
+      resolution.registryUnreachable
+        ? "warning: the operator-signed rate band could NOT be checked because the registry is unreachable. If --rate is outside the band the operator signed, the service's gateway will refuse every request while the deposit stays escrowed. Re-run when the registry answers to have it checked."
+        : "note: this serviceRef has no verified listing, so there is no operator-signed rate band to check --rate against.",
+    );
+    return;
+  }
+  let bounds;
+  try {
+    bounds = await listingRateBand(resolution.record);
+  } catch (error) {
+    if (error instanceof SignedRateBoundsError) {
+      throw new CliError(
+        `the listing's operator-signed rate band could not be verified: ${error.message}`,
+        {
+          exitCode: 4,
+          hint: "nothing was broadcast. The CLI will not open a stream against a rate band it cannot verify.",
+          cause: error,
+        },
+      );
+    }
+    throw error;
+  }
+  if (bounds === null) return;
+  const refusal = rateBandRefusal(ratePerSecondUsdc, bounds, "--rate");
+  if (refusal !== undefined) {
+    throw new CliError(refusal, {
+      exitCode: 2,
+      hint: "pick a --rate inside the signed band (`--units atomic` takes base units; see `metrik discover` for each listing's band).",
+    });
+  }
+}
+
 /**
  * What the buyer is actually paying for.
  *