@zeroxyz/cli 1.8.0 → 1.9.0

package/dist/index.js

@@ -76582,7 +76582,7 @@ init_esm_shims();
 
 // package.json
 var package_default = {
-  version: "1.8.0"};
+  version: "1.9.0"};
 
 // src/app.ts
 init_esm_shims();
@@ -77590,7 +77590,7 @@ init_esm_shims();
 // ../sdk/dist/index.js
 init_esm_shims();
 
-// ../sdk/dist/chunk-W7JBWVWW.js
+// ../sdk/dist/chunk-26IHUYNK.js
 init_esm_shims();
 
 // ../../node_modules/.pnpm/viem@2.52.2_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/index.js
@@ -142971,6 +142971,8 @@ config(en_default2());
 
 // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/index.js
 var zod_default = external_exports3;
+
+// ../sdk/dist/chunk-26IHUYNK.js
 var createManagedAccount = (client, address2) => toAccount({
   address: address2,
   async signMessage({ message: message2 }) {
@@ -144161,718 +144163,1338 @@ var Payments = class {
     };
   };
 };
-var package_default2 = {
-  version: "0.6.0"
-};
-var SDK_VERSION2 = package_default2.version;
-var userWalletDtoSchema = external_exports3.object({
-  walletAddress: external_exports3.string(),
-  source: external_exports3.enum(["self_custody", "privy_embedded"]),
-  isPrimary: external_exports3.boolean(),
-  linkedAt: external_exports3.union([external_exports3.string(), external_exports3.date()]).nullable().optional(),
-  delegationGranted: external_exports3.boolean(),
-  signerQuorumId: external_exports3.string().nullable(),
-  // Per-transaction USDC cap in base units (6 dp). null = unlimited, 0 = free-only.
-  maxTransactionUsdcBaseUnits: external_exports3.number().int().nullable()
-});
-var welcomeBonusSummarySchema = external_exports3.object({
-  status: external_exports3.string(),
-  amountUsd: external_exports3.number()
-});
-var internalUserDtoSchema = external_exports3.object({
-  id: external_exports3.string(),
-  email: external_exports3.string().nullable(),
-  createdAt: external_exports3.union([external_exports3.string(), external_exports3.date()]).optional(),
-  lastLoginAt: external_exports3.union([external_exports3.string(), external_exports3.date()]).nullable().optional(),
-  onboardingCompleted: external_exports3.boolean().optional(),
-  delegationGranted: external_exports3.boolean().optional(),
-  wallets: external_exports3.array(userWalletDtoSchema).optional(),
-  balance: external_exports3.object({ amount: external_exports3.string(), asset: external_exports3.string() }).nullable().optional(),
-  welcomeBonus: welcomeBonusSummarySchema.nullable().optional()
-});
-var publicUserDtoSchema = external_exports3.object({
-  user: external_exports3.object({
-    id: external_exports3.string(),
-    email: external_exports3.string().nullable()
-  }),
-  walletAddress: external_exports3.string().nullable(),
-  balance: external_exports3.object({ amount: external_exports3.string(), asset: external_exports3.string() }).nullable(),
-  welcomeBonus: welcomeBonusSummarySchema.nullable()
-});
-var signResponseSchema = external_exports3.object({
-  signature: external_exports3.string().regex(/^0x[0-9a-fA-F]+$/, "must be 0x-prefixed hex"),
-  walletAddress: external_exports3.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be 0x-prefixed 40-char hex address")
-});
-var deviceStartResponseSchema = external_exports3.object({
-  deviceCode: external_exports3.string(),
-  userCode: external_exports3.string(),
-  verificationUri: external_exports3.string(),
-  pollInterval: external_exports3.number(),
-  expiresAt: external_exports3.number()
-});
-var devicePollResponseSchema = external_exports3.union([
-  // userCode + verificationUri are optional: older API deployments don't
-  // echo them on pending.
-  external_exports3.object({
-    error: external_exports3.literal("authorization_pending"),
-    userCode: external_exports3.string().optional(),
-    verificationUri: external_exports3.string().optional()
-  }),
-  external_exports3.object({ error: external_exports3.literal("expired_token") }),
-  external_exports3.object({
-    accessToken: external_exports3.string(),
-    refreshToken: external_exports3.string(),
-    expiresIn: external_exports3.number(),
-    user: internalUserDtoSchema
-  })
-]);
-var sessionExchangeResponseSchema = external_exports3.object({
-  token: external_exports3.string(),
-  expiresAt: external_exports3.number()
-});
-var refreshResponseSchema = external_exports3.object({
-  accessToken: external_exports3.string(),
-  refreshToken: external_exports3.string()
-});
-var tryRefreshSession = async (client, callerSignal) => {
-  const credentials = client.getCredentials();
-  if (credentials.kind !== "session") return false;
-  if (!credentials.refreshToken) return false;
-  const url4 = `${client.baseUrl.replace(/\/$/, "")}/v1/auth/refresh`;
-  const timeoutSignal = AbortSignal.timeout(client.timeout);
-  const signal = callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
-  let response;
-  try {
-    response = await client.fetchImpl(url4, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ refreshToken: credentials.refreshToken }),
-      signal
-    });
-  } catch {
-    return false;
+var isShortToken = (id) => id.startsWith("z_") && id.indexOf(".", 2) !== -1;
+var MAX_402_PROBE_BYTES = 1024 * 1024;
+var MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
+var TEXT_CONTENT_TYPES = [
+  "application/json",
+  "application/xml",
+  "application/javascript",
+  "application/ecmascript",
+  "application/x-www-form-urlencoded",
+  "text/",
+  "+json",
+  "+xml"
+];
+var MPP_SCHEME_TOKENS = /* @__PURE__ */ new Set(["payment", "mpp"]);
+var splitWwwAuthenticateChallenges = (header) => {
+  const chunks = [];
+  let buf = "";
+  let inQuotes = false;
+  for (let i = 0; i < header.length; i++) {
+    const ch = header[i];
+    if (inQuotes) {
+      if (ch === "\\" && i + 1 < header.length) {
+        buf += ch + header[i + 1];
+        i++;
+        continue;
+      }
+      if (ch === '"') inQuotes = false;
+      buf += ch;
+      continue;
+    }
+    if (ch === '"') {
+      inQuotes = true;
+      buf += ch;
+      continue;
+    }
+    if (ch === ",") {
+      chunks.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
   }
-  if (!response.ok) return false;
-  let body;
+  if (buf.length > 0) chunks.push(buf);
+  return chunks;
+};
+var isTextContentType = (contentType) => {
+  if (!contentType) return true;
+  const lower = contentType.toLowerCase();
+  return TEXT_CONTENT_TYPES.some((marker) => lower.includes(marker));
+};
+var redactUrl2 = (url4) => {
   try {
-    body = await response.json();
+    const u2 = new URL(url4);
+    return `${u2.origin}${u2.pathname}`;
   } catch {
-    return false;
+    return "<invalid url>";
   }
-  const parsed = refreshResponseSchema.safeParse(body);
-  if (!parsed.success) return false;
-  await client.applyRefreshedTokens({
-    accessToken: parsed.data.accessToken,
-    refreshToken: parsed.data.refreshToken
-  });
-  return true;
-};
-var buildSessionAuthHeaders = (accessToken) => ({
-  authorization: `Bearer ${accessToken}`
-});
-var buildCanonicalMessage = (method, pathWithQuery, body, timestamp, nonce2) => {
-  const bodyHash = createHash("sha256").update(body ?? "").digest("hex");
-  return `${method}:${pathWithQuery}:${bodyHash}:${timestamp}:${nonce2}`;
 };
-var buildAccountAuthHeaders = async (account, method, pathWithQuery, body) => {
-  const timestamp = Math.floor(Date.now() / 1e3).toString();
-  const nonce2 = crypto.randomUUID();
-  const message2 = buildCanonicalMessage(
-    method,
-    pathWithQuery,
-    body,
-    timestamp,
-    nonce2
+var ECHO_DETECT_MIN_LEN = 16;
+var ECHO_DETECT_MAX_SCAN = 64 * 1024;
+var requestBodyEchoed = (candidate, requestBody) => {
+  if (requestBody === void 0) return false;
+  const asString = typeof requestBody === "string" ? requestBody : new TextDecoder("utf-8", { fatal: false }).decode(
+    requestBody.byteLength > ECHO_DETECT_MAX_SCAN ? requestBody.subarray(0, ECHO_DETECT_MAX_SCAN) : requestBody
   );
-  const signature2 = await account.signMessage({ message: message2 });
-  return {
-    "x-zero-address": account.address,
-    "x-zero-timestamp": timestamp,
-    "x-zero-nonce": nonce2,
-    "x-zero-signature": signature2
-  };
-};
-var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 502, 503, 504]);
-var sleep2 = (ms, signal) => new Promise((resolve6, reject) => {
-  if (signal?.aborted) {
-    reject(new DOMException("Aborted", "AbortError"));
-    return;
-  }
-  const timer = setTimeout(() => {
-    signal?.removeEventListener("abort", onAbort);
-    resolve6();
-  }, ms);
-  const onAbort = () => {
-    clearTimeout(timer);
-    reject(new DOMException("Aborted", "AbortError"));
-  };
-  signal?.addEventListener("abort", onAbort, { once: true });
-});
-var buildPathWithQuery = (path3, query) => {
-  const normalizedPath = path3.startsWith("/") ? path3 : `/${path3}`;
-  if (!query) return normalizedPath;
-  const params = new URLSearchParams();
-  for (const [key, value] of Object.entries(query)) {
-    if (value !== void 0) params.set(key, String(value));
-  }
-  const qs = params.toString();
-  return qs ? `${normalizedPath}?${qs}` : normalizedPath;
-};
-var joinUrl = (baseUrl, pathWithQuery) => {
-  const base3 = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-  return `${base3}${pathWithQuery}`;
-};
-var buildHeaders = async (client, method, pathWithQuery, hasBody, bodyStr) => {
-  const headers = { ...client.defaultHeaders };
-  if (hasBody) headers["content-type"] = "application/json";
-  headers["x-zero-sdk-version"] = SDK_VERSION2;
-  if (client.apiVersion) headers["x-zero-api-version"] = client.apiVersion;
-  const credentials = client.getCredentials();
-  if (credentials.kind === "session") {
-    Object.assign(headers, buildSessionAuthHeaders(credentials.accessToken));
-  } else if (credentials.kind === "account") {
-    const signed = await buildAccountAuthHeaders(
-      credentials.account,
-      method,
-      pathWithQuery,
-      bodyStr
-    );
-    Object.assign(headers, signed);
+  if (asString.length < ECHO_DETECT_MIN_LEN) return false;
+  const scanLen = Math.min(asString.length, ECHO_DETECT_MAX_SCAN);
+  for (let i = 0; i + ECHO_DETECT_MIN_LEN <= scanLen; i++) {
+    if (candidate.includes(asString.slice(i, i + ECHO_DETECT_MIN_LEN))) {
+      return true;
+    }
   }
-  return headers;
+  return false;
 };
-var parseErrorBody = async (response) => {
+var cancelBody2 = (response) => {
   try {
-    return await response.clone().json();
+    response.body?.cancel().catch(() => {
+    });
   } catch {
+  }
+};
+var detectPaymentRequirement = async (response) => {
+  if (response.status !== 402) return null;
+  const x402Header = response.headers.get("payment-required") ?? response.headers.get("x-payment-required");
+  if (x402Header) {
+    cancelBody2(response);
     try {
-      return await response.text();
+      const decoded = JSON.parse(
+        Buffer.from(x402Header, "base64").toString("utf8")
+      );
+      return { protocol: "x402", raw: decoded };
     } catch {
-      return void 0;
+      return { protocol: "x402", raw: { encoded: x402Header } };
     }
   }
-};
-var errorMessageFromBody = (body, status) => {
-  if (body !== null && typeof body === "object" && "error" in body && typeof body.error === "string") {
-    return body.error;
-  }
-  return `HTTP ${status}`;
-};
-var request2 = async (client, opts, schema) => {
-  const pathWithQuery = buildPathWithQuery(opts.path, opts.query);
-  const url4 = joinUrl(client.baseUrl, pathWithQuery);
-  const hasBody = opts.body !== void 0;
-  const bodyStr = hasBody ? JSON.stringify(
-    opts.body,
-    (_k, v) => typeof v === "bigint" ? v.toString() : v
-  ) : void 0;
-  const configuredFetch = buildConfiguredFetch(client);
-  const performOnce = async () => configuredFetch(url4, {
-    method: opts.method,
-    headers: await buildHeaders(
-      client,
-      opts.method,
-      pathWithQuery,
-      hasBody,
-      bodyStr
-    ),
-    body: bodyStr,
-    signal: opts.signal
-  });
-  let refreshAttempted = false;
-  const executeWithRefresh = async () => {
-    const response = await performOnce();
-    if (response.status !== 401 || refreshAttempted) return response;
-    const credentials = client.getCredentials();
-    if (credentials.kind !== "session") return response;
-    refreshAttempted = true;
-    const refreshed = await client.refreshSessionOnce(opts.signal);
-    if (!refreshed) return response;
-    return await performOnce();
-  };
-  let lastNetworkError;
-  for (let attempt = 0; attempt <= client.maxRetries; attempt++) {
-    let response;
+  const declaredLen = Number.parseInt(
+    response.headers.get("content-length") ?? "",
+    10
+  );
+  const bodyFits = !Number.isFinite(declaredLen) || declaredLen <= MAX_402_PROBE_BYTES;
+  if (bodyFits) {
     try {
-      response = await executeWithRefresh();
-    } catch (e2) {
-      if (e2 instanceof ZeroError) throw e2;
-      lastNetworkError = e2;
-      if (attempt < client.maxRetries) {
-        try {
-          await sleep2(2 ** attempt * 200, opts.signal);
-        } catch (sleepErr) {
-          throw new ZeroApiError("Request aborted by caller", {
-            status: 0,
-            cause: sleepErr
-          });
+      const text = await readClippedText(response, MAX_402_PROBE_BYTES);
+      if (text) {
+        const parsed = JSON.parse(text);
+        if (looksLikeX402Body(parsed)) {
+          return { protocol: "x402", raw: parsed };
         }
-        continue;
-      }
-      throw new ZeroApiError("Network request failed", {
-        status: 0,
-        cause: e2
-      });
-    }
-    if (response.ok) {
-      let text;
-      try {
-        text = await response.text();
-      } catch (e2) {
-        throw new ZeroApiError("Response body read failed", {
-          status: response.status,
-          cause: e2
-        });
-      }
-      let json3;
-      try {
-        json3 = JSON.parse(text);
-      } catch {
-      }
-      const parsed = schema.safeParse(json3);
-      if (!parsed.success) {
-        throw new ZeroValidationError(
-          `Response did not match expected schema for ${opts.method} ${opts.path}`,
-          { cause: parsed.error, body: text }
-        );
       }
-      return parsed.data;
+    } catch {
     }
-    if (RETRYABLE_STATUS.has(response.status) && attempt < client.maxRetries) {
-      try {
-        await sleep2(2 ** attempt * 200, opts.signal);
-      } catch (sleepErr) {
-        throw new ZeroApiError("Request aborted by caller", {
-          status: 0,
-          cause: sleepErr
-        });
-      }
-      continue;
+  }
+  const wwwAuth = response.headers.get("www-authenticate");
+  if (wwwAuth) {
+    const schemes = splitWwwAuthenticateChallenges(wwwAuth).map(
+      (challenge2) => challenge2.trim().split(/\s+/)[0]?.toLowerCase() ?? ""
+    );
+    if (schemes.some((scheme) => MPP_SCHEME_TOKENS.has(scheme))) {
+      cancelBody2(response);
+      return { protocol: "mpp", raw: { "www-authenticate": wwwAuth } };
     }
-    const errorBody = await parseErrorBody(response);
-    const requestId = response.headers.get("x-request-id") ?? void 0;
-    throw new ZeroApiError(errorMessageFromBody(errorBody, response.status), {
-      status: response.status,
-      requestId,
-      body: errorBody
-    });
   }
-  throw new ZeroApiError("Exhausted retries", {
-    status: 0,
-    cause: lastNetworkError
-  });
+  cancelBody2(response);
+  return { protocol: "unknown", raw: {} };
 };
-var AuthDevice = class {
-  constructor(client) {
-    this.client = client;
-  }
-  start = (opts = {}) => request2(
-    this.client,
-    {
-      method: "POST",
-      path: "/v1/auth/device/start",
-      signal: opts.signal
-    },
-    deviceStartResponseSchema
-  );
-  poll = async (deviceCode, opts = {}) => {
-    const parsed = await request2(
-      this.client,
-      {
-        method: "POST",
-        path: "/v1/auth/device/poll",
-        body: { deviceCode },
-        signal: opts.signal
-      },
-      devicePollResponseSchema
-    );
-    if ("error" in parsed) {
-      return parsed.error === "authorization_pending" ? {
-        status: "pending",
-        userCode: parsed.userCode,
-        verificationUri: parsed.verificationUri
-      } : { status: "expired" };
+var readClippedBytes = async (response, max) => {
+  if (response.body === null) return new Uint8Array(0);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (total < max) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {
     }
+  }
+  const merged = new Uint8Array(Math.min(total, max));
+  let offset = 0;
+  for (const c of chunks) {
+    const take = Math.min(c.byteLength, max - offset);
+    merged.set(c.subarray(0, take), offset);
+    offset += take;
+    if (offset >= max) break;
+  }
+  return merged;
+};
+var readClippedText = async (response, max) => {
+  const bytes = await readClippedBytes(response, max);
+  return new TextDecoder().decode(bytes);
+};
+var parseResponseBody = async (response, max) => {
+  const contentType = response.headers.get("content-type");
+  const bytes = await readClippedBytes(response, max + 1);
+  const truncated = bytes.byteLength > max;
+  const view = truncated ? bytes.subarray(0, max) : bytes;
+  const buf = Buffer.from(view.buffer, view.byteOffset, view.byteLength);
+  if (!isTextContentType(contentType)) {
+    const base644 = buf.toString("base64");
     return {
-      status: "ok",
-      accessToken: parsed.accessToken,
-      refreshToken: parsed.refreshToken,
-      expiresIn: parsed.expiresIn,
-      user: parsed.user
+      body: base644,
+      bodyRaw: base644,
+      bodyEncoding: "base64",
+      truncated
     };
-  };
+  }
+  const text = buf.toString("utf8");
+  if (contentType?.toLowerCase().includes("json")) {
+    try {
+      return { body: JSON.parse(text), bodyRaw: text, truncated };
+    } catch {
+    }
+  }
+  return { body: text, bodyRaw: text, truncated };
 };
-var userWalletsSchema = external_exports3.array(userWalletDtoSchema);
-var normalizeMessage = (message2) => {
-  if (typeof message2 === "string") return message2;
-  if (typeof message2.raw === "string") return message2.raw;
-  return bytesToHex(message2.raw);
+var UPSTREAM_ERROR_FIELDS = [
+  "error",
+  "message",
+  "detail",
+  "reason",
+  "error_description"
+];
+var UPSTREAM_ERROR_MAX_LEN = 200;
+var ERROR_SNIPPET_BYTES = 500;
+var clampUpstreamMessage = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  return trimmed.length > UPSTREAM_ERROR_MAX_LEN ? `${trimmed.slice(0, UPSTREAM_ERROR_MAX_LEN)}\u2026` : trimmed;
 };
-var repackageSignFailure = (err, op) => {
-  if (err instanceof ZeroApiError && err.status === 402) {
-    const body = err.body;
-    const detail = body && typeof body.error === "string" ? `: ${body.error}` : "";
-    throw new ZeroPaymentError(
-      `Sign endpoint refused ${op} (HTTP 402)${detail}`,
-      { cause: err }
-    );
+var tryParseJson = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
   }
-  throw err;
 };
-var Auth = class {
-  constructor(client) {
-    this.client = client;
-    this.device = new AuthDevice(client);
+var extractUpstreamErrorMessage = (body) => {
+  const parsed = tryParseJson(body);
+  if (parsed === null || typeof parsed !== "object") {
+    return clampUpstreamMessage(body);
   }
-  device;
-  // The internal (web-app facing) user profile. Richer than profile(): full
-  // wallet list with per-wallet delegation/signer/limit metadata.
-  me = (opts = {}) => request2(
-    this.client,
-    { method: "GET", path: "/v1/users/me", signal: opts.signal },
-    internalUserDtoSchema
-  );
-  // The public (agent-facing) profile — identity + primary wallet address +
-  // balance + welcome-bonus, no per-wallet metadata. Same shape the MCP
-  // get_profile tool returns; rendered by `zero auth whoami`.
-  profile = (opts = {}) => request2(
-    this.client,
-    { method: "GET", path: "/v1/users/me/profile", signal: opts.signal },
-    publicUserDtoSchema
+  const record3 = parsed;
+  for (const field of UPSTREAM_ERROR_FIELDS) {
+    const value = record3[field];
+    if (typeof value === "string" && value.length > 0) {
+      return clampUpstreamMessage(value);
+    }
+    if (value && typeof value === "object") {
+      const nested = value.message;
+      if (typeof nested === "string" && nested.length > 0) {
+        return clampUpstreamMessage(nested);
+      }
+    }
+  }
+  return void 0;
+};
+var buildUpstreamError = (status, bodyRaw, bodyEncoding) => {
+  if (status >= 200 && status < 300) return void 0;
+  if (bodyRaw === null || bodyRaw.length === 0) return void 0;
+  if (bodyEncoding === "base64") return void 0;
+  const snippet = bodyRaw.slice(0, ERROR_SNIPPET_BYTES);
+  return {
+    status,
+    message: extractUpstreamErrorMessage(bodyRaw),
+    snippetHash: createHash("sha256").update(snippet).digest("hex"),
+    snippetLength: snippet.length
+  };
+};
+var computeOutcome = (status, payment, warnings) => {
+  if (warnings.includes(FETCH_WARNINGS.mppSessionCloseFailed))
+    return "payment_close_failed";
+  if (status === 402 && payment !== null) return "payment_rejected";
+  if (status === 402) return "payment_failed";
+  if (status >= 400) return "server_error";
+  return "success";
+};
+var errorFetchResult = (startedAt, error48, skipReason, capabilityIdRequested, outcome, status = null) => {
+  const result = {
+    runId: null,
+    ok: false,
+    status,
+    latencyMs: Date.now() - startedAt,
+    payment: null,
+    outcome,
+    body: null,
+    bodyRaw: null,
+    error: error48
+  };
+  if (capabilityIdRequested) result.runTrackingSkipped = [skipReason];
+  return result;
+};
+var resolveRecordingClient = (client, opts) => {
+  const credentials = client.getCredentials();
+  const recordingClient = opts.account ? client.withAccount(opts.account) : client;
+  const canRecord = opts.account !== void 0 || credentials.kind === "account" || credentials.kind === "session";
+  return { recordingClient, canRecord };
+};
+var recordErrorFetchRun = async (client, opts, result, capabilityIdOverride) => {
+  const effectiveCapId = opts.capabilityId;
+  if (effectiveCapId === void 0) return;
+  const { recordingClient, canRecord } = resolveRecordingClient(client, opts);
+  if (!canRecord) return;
+  const fetchOriginForRecord = opts.capabilityId === void 0 ? "direct_url" : isShortToken(effectiveCapId) ? "from_search" : opts.fetchOrigin;
+  try {
+    const created = await recordingClient.runs.create({
+      capabilityId: effectiveCapId,
+      ...opts.searchId && { searchId: opts.searchId },
+      ...fetchOriginForRecord && { fetchOrigin: fetchOriginForRecord },
+      ...result.status !== null && { status: result.status },
+      latencyMs: result.latencyMs,
+      ...opts.requestSchema && { requestSchema: opts.requestSchema }
+    });
+    result.runId = created.runId;
+    delete result.runTrackingSkipped;
+  } catch {
+  }
+};
+var recordTimeoutRun = async (client, opts, err, startedAt, capabilityIdRequested, capabilityIdOverride) => {
+  const result = errorFetchResult(
+    startedAt,
+    err.message,
+    "timeout",
+    capabilityIdRequested,
+    "network_error"
   );
-  // The user's wallets only. Lightweight sibling of `me()` for callers that
-  // just need wallet addresses (e.g. managed-account resolution on the pay
-  // path) — avoids the heavier internal-profile computation behind `me()`.
-  wallets = (opts = {}) => request2(
-    this.client,
-    { method: "GET", path: "/v1/users/me/wallets", signal: opts.signal },
-    userWalletsSchema
+  await recordErrorFetchRun(client, opts, result);
+};
+var sniffJsonShapeBytes = (buf) => {
+  let i = 0;
+  if (buf.length >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) {
+    i = 3;
+  }
+  while (i < buf.length && (buf[i] === 32 || buf[i] === 9 || buf[i] === 10 || buf[i] === 13)) {
+    i++;
+  }
+  if (i >= buf.length) return false;
+  return buf[i] === 123 || buf[i] === 91;
+};
+var withDefaultContentType = (headers, body) => {
+  if (!headers && body === void 0) return void 0;
+  const next = headers ? { ...headers } : {};
+  if (body === void 0) return next;
+  const hasContentType = Object.keys(next).some(
+    (k3) => k3.toLowerCase() === "content-type"
   );
-  // Exchange an ephemeral session code (e.g. runner / sandbox handoff) for
-  // a session access token. The returned token has no refresh path — pair
-  // with `refreshToken: ""` when constructing the client.
-  exchangeSessionCode = (code, opts = {}) => request2(
-    this.client,
-    {
-      method: "POST",
-      path: "/v1/session/exchange",
-      body: { code },
-      signal: opts.signal
-    },
-    sessionExchangeResponseSchema
+  if (!hasContentType) {
+    next["content-type"] = typeof body === "string" || sniffJsonShapeBytes(body) ? "application/json" : "application/octet-stream";
+  }
+  return next;
+};
+var clientFetch = async (client, url4, opts = {}) => {
+  const startedAt = Date.now();
+  const capabilityIdRequested = opts.capabilityId !== void 0;
+  const normalized = normalizeTransportEnvelopeRequest(url4, {
+    method: opts.method,
+    body: opts.body
+  });
+  const requestUrl = normalized.url;
+  const requestBody = normalized.body;
+  const method = normalized.method ?? (requestBody !== void 0 ? "POST" : "GET");
+  const { canRecord: canRecordForResolve } = resolveRecordingClient(
+    client,
+    opts
   );
-  // Server-side revoke of the refresh token. Throws ZeroApiError on any
-  // non-2xx — callers that have already cleared local state (e.g. CLI
-  // logout) typically want to swallow with `.catch(() => {})` so a flaky
-  // server doesn't surface as a user-visible failure for a sign-out that
-  // already succeeded locally. Response body is opaque; schema is
-  // `z.unknown()` and the resolved value is discarded.
-  logout = async (refreshToken, opts = {}) => {
-    await request2(
-      this.client,
-      {
-        method: "POST",
-        path: "/v1/auth/logout",
-        body: { refreshToken },
-        signal: opts.signal
-      },
-      external_exports3.unknown()
-    );
+  const resolvePromise = !capabilityIdRequested && canRecordForResolve ? client.capabilities.resolveByUrl(redactUrl2(requestUrl), method).catch(() => null) : Promise.resolve(null);
+  const probeHeaders = withDefaultContentType(opts.headers, requestBody);
+  const requestInit = {
+    method,
+    headers: probeHeaders,
+    body: requestBody,
+    signal: opts.signal
   };
-  // Force a session refresh. Routes through refreshSessionOnce() so a
-  // proactive call doesn't race a 401-driven transport refresh —
-  // concurrent POSTs with the same refresh token kill the session
-  // family (RFC 6819 token-theft response).
-  refresh = async () => {
-    const credentials = this.client.getCredentials();
-    if (credentials.kind !== "session") {
-      throw new ZeroAuthError(
-        "auth_no_credentials",
-        "refresh() requires the client to be constructed with a session \u2014 got credentials.kind=" + credentials.kind
-      );
-    }
-    const ok = await this.client.refreshSessionOnce();
-    if (!ok) {
-      throw new ZeroAuthError(
-        "auth_session_expired",
-        "Session refresh failed. The refresh token may be revoked or expired."
+  const configuredFetch = buildConfiguredFetch(client, {
+    timeoutMs: opts.timeoutMs
+  });
+  let response;
+  let payment = null;
+  const skipReasons = [];
+  const warnings = [];
+  try {
+    response = await configuredFetch(requestUrl, requestInit);
+  } catch (err) {
+    if (err instanceof ZeroTimeoutError) {
+      await recordTimeoutRun(
+        client,
+        opts,
+        err,
+        startedAt,
+        capabilityIdRequested
       );
+      throw err;
     }
-  };
-  signMessage = async (input, opts = {}) => {
-    const credentials = this.client.getCredentials();
-    if (credentials.kind === "account") {
-      return await credentials.account.signMessage({ message: input.message });
-    }
-    if (credentials.kind === "session") {
-      try {
-        const parsed = await request2(
-          this.client,
-          {
-            method: "POST",
-            path: "/v1/users/me/sign-message",
-            body: { message: normalizeMessage(input.message) }
-          },
-          signResponseSchema
-        );
-        this.assertSignerMatches(parsed.walletAddress, opts.expectedAddress);
-        return parsed.signature;
-      } catch (err) {
-        repackageSignFailure(err, "signMessage");
-      }
-    }
-    throw new ZeroAuthError(
-      "auth_no_credentials",
-      "signMessage() requires the client to be constructed with `account` or `session`."
+    if (err instanceof ZeroError) throw err;
+    const errMessage = err instanceof Error ? err.message : String(err);
+    const result2 = errorFetchResult(
+      startedAt,
+      errMessage,
+      "fetch_failed_before_response",
+      capabilityIdRequested,
+      "network_error"
     );
-  };
-  // Managed-only: BYO accounts sign locally via viem's account.signTransaction.
-  signTransaction = async (input, opts = {}) => {
-    const credentials = this.client.getCredentials();
-    if (credentials.kind === "session") {
+    await recordErrorFetchRun(client, opts, result2);
+    return result2;
+  }
+  if (response.status === 402) {
+    const requirement = await detectPaymentRequirement(response);
+    if (requirement?.protocol === "x402" || requirement?.protocol === "mpp") {
+      const payCall = requirement.protocol === "x402" ? client.payments.pay : client.payments.payMpp;
       try {
-        const parsed = await request2(
-          this.client,
-          {
-            method: "POST",
-            path: "/v1/users/me/sign-transaction",
-            body: { unsignedTransaction: input.unsignedTransaction }
-          },
-          signResponseSchema
-        );
-        this.assertSignerMatches(parsed.walletAddress, opts.expectedAddress);
-        return parsed.signature;
+        const paid = await payCall({
+          url: requestUrl,
+          method,
+          // Fresh clone for the paid retry — same rationale as
+          // the probe-side clone above. Re-derives the default
+          // Content-Type so the paid leg matches the probe.
+          headers: withDefaultContentType(opts.headers, requestBody),
+          body: requestBody,
+          maxPay: opts.maxPay,
+          account: opts.account,
+          signal: opts.signal,
+          timeoutMs: opts.timeoutMs,
+          ...opts.displayCostAmount && {
+            displayCostAmount: opts.displayCostAmount
+          }
+        });
+        response = paid.response;
+        payment = paid.payment;
+        if (paid.warnings) warnings.push(...paid.warnings);
       } catch (err) {
-        repackageSignFailure(err, "signTransaction");
+        if (err instanceof ZeroSessionCloseFailedError) {
+          response = err.response;
+          payment = {
+            protocol: "mpp",
+            chain: tempoChainLabelFromId(err.session.chainId),
+            txHash: null,
+            amount: err.capturedAmount,
+            asset: "USDC",
+            session: err.session
+          };
+          warnings.push(FETCH_WARNINGS.mppSessionCloseFailed);
+        } else if (err instanceof ZeroInsufficientFundsError) {
+          return errorFetchResult(
+            startedAt,
+            err.message,
+            FETCH_SKIP_REASONS.insufficientFunds,
+            capabilityIdRequested,
+            "insufficient_funds",
+            null
+          );
+        } else if (err instanceof ZeroPaymentError || err instanceof ZeroAuthError) {
+          const result2 = errorFetchResult(
+            startedAt,
+            err.message,
+            "payment_failed",
+            capabilityIdRequested,
+            "payment_failed",
+            402
+          );
+          await recordErrorFetchRun(client, opts, result2);
+          return result2;
+        } else if (err instanceof ZeroTimeoutError) {
+          await recordTimeoutRun(
+            client,
+            opts,
+            err,
+            startedAt,
+            capabilityIdRequested
+          );
+          throw err;
+        } else {
+          throw err;
+        }
       }
-    }
-    if (credentials.kind === "account") {
-      throw new ZeroAuthError(
-        "auth_error",
-        "signTransaction() is a managed-signing operation and is not supported in account mode. Sign locally with viem's account.signTransaction instead."
+    } else if (requirement?.protocol === "unknown") {
+      const result2 = errorFetchResult(
+        startedAt,
+        "Capability returned 402 with an unrecognized payment protocol. Neither x402 nor MPP markers were detected in the response headers or body.",
+        "unrecognized_402_protocol",
+        capabilityIdRequested,
+        "payment_failed",
+        402
       );
+      await recordErrorFetchRun(client, opts, result2);
+      return result2;
     }
-    throw new ZeroAuthError(
-      "auth_no_credentials",
-      "signTransaction() requires session credentials (managed signing)."
-    );
-  };
-  signTypedData = async (input, opts = {}) => {
-    const credentials = this.client.getCredentials();
-    if (credentials.kind === "account") {
-      if (!credentials.account.signTypedData) {
-        throw new ZeroAuthError(
-          "auth_error",
-          "The configured viem account does not implement signTypedData."
-        );
-      }
-      return await credentials.account.signTypedData(input);
+  }
+  const latencyMs = Date.now() - startedAt;
+  const maxResponseBytes = opts.maxResponseBytes ?? MAX_RESPONSE_BYTES;
+  let body;
+  let bodyRaw;
+  let bodyEncoding;
+  try {
+    const parsed = await parseResponseBody(response, maxResponseBytes);
+    body = parsed.body;
+    bodyRaw = parsed.bodyRaw;
+    bodyEncoding = parsed.bodyEncoding;
+    if (parsed.truncated) warnings.push(FETCH_WARNINGS.bodyTruncated);
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new ZeroApiError("Request aborted by caller", {
+        status: 0,
+        cause: err
+      });
     }
-    if (credentials.kind === "session") {
+    const message2 = err instanceof Error ? err.message : String(err);
+    const skips = [];
+    const settledLocally = paymentHasAnchor(payment);
+    if (settledLocally && response.status === 402) {
+      warnings.push(FETCH_WARNINGS.paidButStill402NotRecorded);
+      skips.push(FETCH_WARNINGS.paidButStill402NotRecorded);
+    }
+    if (payment !== null && !settledLocally) {
+      warnings.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
+      skips.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
+    }
+    if (payment !== null && payment.amount === "unknown") {
+      warnings.push(FETCH_WARNINGS.paymentAmountUnknown);
+    }
+    skips.push(FETCH_SKIP_REASONS.bodyReadFailed);
+    const result2 = {
+      runId: null,
+      ok: false,
+      status: response.status,
+      latencyMs: Date.now() - startedAt,
+      payment,
+      outcome: computeOutcome(response.status, payment, warnings),
+      body: null,
+      bodyRaw: null,
+      error: message2
+    };
+    if (capabilityIdRequested) result2.runTrackingSkipped = skips;
+    if (warnings.length > 0) result2.warnings = warnings;
+    return result2;
+  }
+  const settled = paymentHasAnchor(payment);
+  const paidButStill402 = settled && response.status === 402;
+  const settlementUnconfirmed = payment !== null && !settled;
+  if (paidButStill402) warnings.push(FETCH_WARNINGS.paidButStill402NotRecorded);
+  if (settlementUnconfirmed)
+    warnings.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
+  if (payment !== null && payment.amount === "unknown") {
+    warnings.push(FETCH_WARNINGS.paymentAmountUnknown);
+  }
+  let runId = null;
+  const closeFailed = warnings.includes(FETCH_WARNINGS.mppSessionCloseFailed);
+  const upstreamErrorForRecord = buildUpstreamError(
+    response.status,
+    bodyRaw,
+    bodyEncoding
+  );
+  if (capabilityIdRequested) {
+    if (paidButStill402)
+      skipReasons.push(FETCH_WARNINGS.paidButStill402NotRecorded);
+    else if (closeFailed)
+      skipReasons.push(FETCH_SKIP_REASONS.mppSessionCloseFailedNotRecorded);
+  }
+  const resolvedCap = await resolvePromise;
+  const effectiveCapabilityId = opts.capabilityId ?? resolvedCap?.capabilityId;
+  const capabilityResolution = !capabilityIdRequested && canRecordForResolve ? resolvedCap !== null ? {
+    resolved: true,
+    capabilityId: resolvedCap.capabilityId,
+    capabilitySlug: resolvedCap.capabilitySlug,
+    matchedVia: resolvedCap.matchedVia
+  } : { resolved: false } : void 0;
+  if (effectiveCapabilityId !== void 0 && !paidButStill402 && !closeFailed) {
+    const { recordingClient, canRecord } = resolveRecordingClient(client, opts);
+    if (!canRecord) {
+      skipReasons.push("no_credentials");
+    } else {
+      const knownAmount = payment !== null && payment.amount !== "unknown";
       try {
-        const parsed = await request2(
-          this.client,
-          {
-            method: "POST",
-            path: "/v1/users/me/sign-typed-data",
-            body: { typedData: input }
+        let derived;
+        if (opts.deriveRunMetadata) {
+          try {
+            derived = opts.deriveRunMetadata({
+              status: response.status,
+              ok: response.ok,
+              bodyRaw,
+              ...bodyEncoding && { bodyEncoding }
+            });
+          } catch {
+          }
+        }
+        const result2 = await recordingClient.runs.create({
+          capabilityId: effectiveCapabilityId,
+          searchId: opts.searchId,
+          // Auto-resolved runs are always direct_url — they only fire when
+          // no capabilityId was supplied (the direct_url path by definition).
+          ...opts.capabilityId === void 0 ? { fetchOrigin: "direct_url" } : opts.fetchOrigin && { fetchOrigin: opts.fetchOrigin },
+          status: response.status,
+          latencyMs,
+          ...opts.requestSchema && { requestSchema: opts.requestSchema },
+          ...derived?.responseSchema && {
+            responseSchema: derived.responseSchema
           },
-          signResponseSchema
-        );
-        this.assertSignerMatches(parsed.walletAddress, opts.expectedAddress);
-        return parsed.signature;
+          ...upstreamErrorForRecord && {
+            errorSnippetHash: upstreamErrorForRecord.snippetHash,
+            errorSnippetLength: upstreamErrorForRecord.snippetLength
+          },
+          ...payment && {
+            ...knownAmount && {
+              costAmount: payment.amount,
+              costAsset: payment.asset
+            },
+            paymentProtocol: payment.protocol,
+            paymentChain: payment.chain,
+            paymentTxHash: payment.txHash ?? void 0,
+            paymentMode: payment.session ? "session" : "charge"
+          }
+        });
+        runId = result2.runId;
       } catch (err) {
-        repackageSignFailure(err, "signTypedData");
+        const errorMessage22 = err instanceof Error ? err.message : String(err);
+        const code = err instanceof ZeroError ? err.code : void 0;
+        const skipMsg = code ? `run_create_failed:${code}: ${errorMessage22}` : `run_create_failed: ${errorMessage22}`;
+        skipReasons.push(skipMsg);
+        client.logger?.({
+          level: "warn",
+          message: "Failed to record run for fetch",
+          meta: {
+            url: redactUrl2(url4),
+            capabilityId: effectiveCapabilityId,
+            error: errorMessage22,
+            errorCode: code
+          }
+        });
       }
     }
-    throw new ZeroAuthError(
-      "auth_no_credentials",
-      "signTypedData() requires the client to be constructed with `account` or `session`."
-    );
-  };
-  // Compare against the caller's pinned address (not shared cache) so
-  // concurrent pay()s can't race past each other. Mismatch → clear + throw;
-  // the caller's retry rebuilds against the new wallet.
-  assertSignerMatches = (serverAddr, expectedAddr) => {
-    if (!expectedAddr) return;
-    const canonicalServer = getAddress(serverAddr);
-    const canonicalExpected = getAddress(expectedAddr);
-    if (canonicalExpected === canonicalServer) return;
-    this.client.clearManagedAccount();
-    throw new ZeroAuthError(
-      "auth_error",
-      `Managed signing wallet changed (caller expected ${canonicalExpected}, server signed as ${canonicalServer}). Cache cleared \u2014 retry to rebuild against the current wallet.`
-    );
+  }
+  const result = {
+    runId,
+    ok: response.ok,
+    status: response.status,
+    latencyMs,
+    payment,
+    outcome: computeOutcome(response.status, payment, warnings),
+    body,
+    bodyRaw
   };
+  if (bodyEncoding) result.bodyEncoding = bodyEncoding;
+  if (!response.ok) {
+    const candidate = bodyRaw !== null && bodyRaw.length > 0 && bodyEncoding !== "base64" ? bodyRaw.slice(0, 240) : null;
+    result.error = candidate !== null && !requestBodyEchoed(candidate, opts.body) ? candidate : `HTTP ${response.status}`;
+    if (upstreamErrorForRecord) result.upstreamError = upstreamErrorForRecord;
+  }
+  if (capabilityIdRequested && skipReasons.length > 0) {
+    result.runTrackingSkipped = skipReasons;
+  }
+  if (warnings.length > 0) result.warnings = warnings;
+  if (capabilityResolution !== void 0)
+    result.capabilityResolution = capabilityResolution;
+  return result;
 };
-var BUG_REPORT_CATEGORIES = [
-  "search_relevance",
-  "ranking_issue",
-  "missing_capability",
-  "wrong_schema",
-  "misleading_description",
-  "broken_execution",
-  "payment_failure",
-  "billing_anomaly",
-  "cli_bug",
-  "security",
-  "other"
-];
-var createBugReportResponseSchema = external_exports3.object({
-  bugReportId: external_exports3.string(),
+var package_default2 = {
+  version: "0.7.0"
+};
+var SDK_VERSION2 = package_default2.version;
+var userWalletDtoSchema = external_exports3.object({
+  walletAddress: external_exports3.string(),
+  source: external_exports3.enum(["self_custody", "privy_embedded"]),
+  isPrimary: external_exports3.boolean(),
+  linkedAt: external_exports3.union([external_exports3.string(), external_exports3.date()]).nullable().optional(),
+  delegationGranted: external_exports3.boolean(),
+  signerQuorumId: external_exports3.string().nullable(),
+  // Per-transaction USDC cap in base units (6 dp). null = unlimited, 0 = free-only.
+  maxTransactionUsdcBaseUnits: external_exports3.number().int().nullable()
+});
+var welcomeBonusSummarySchema = external_exports3.object({
   status: external_exports3.string(),
-  deduped: external_exports3.boolean(),
-  category: external_exports3.enum(BUG_REPORT_CATEGORIES).nullable(),
-  title: external_exports3.string().nullable(),
-  attached: external_exports3.object({
-    capabilityId: external_exports3.number().nullable(),
-    runId: external_exports3.number().nullable(),
-    searchId: external_exports3.number().nullable()
+  amountUsd: external_exports3.number()
+});
+var internalUserDtoSchema = external_exports3.object({
+  id: external_exports3.string(),
+  email: external_exports3.string().nullable(),
+  createdAt: external_exports3.union([external_exports3.string(), external_exports3.date()]).optional(),
+  lastLoginAt: external_exports3.union([external_exports3.string(), external_exports3.date()]).nullable().optional(),
+  onboardingCompleted: external_exports3.boolean().optional(),
+  delegationGranted: external_exports3.boolean().optional(),
+  wallets: external_exports3.array(userWalletDtoSchema).optional(),
+  balance: external_exports3.object({ amount: external_exports3.string(), asset: external_exports3.string() }).nullable().optional(),
+  welcomeBonus: welcomeBonusSummarySchema.nullable().optional()
+});
+var publicUserDtoSchema = external_exports3.object({
+  user: external_exports3.object({
+    id: external_exports3.string(),
+    email: external_exports3.string().nullable()
+  }),
+  walletAddress: external_exports3.string().nullable(),
+  balance: external_exports3.object({ amount: external_exports3.string(), asset: external_exports3.string() }).nullable(),
+  welcomeBonus: welcomeBonusSummarySchema.nullable()
+});
+var signResponseSchema = external_exports3.object({
+  signature: external_exports3.string().regex(/^0x[0-9a-fA-F]+$/, "must be 0x-prefixed hex"),
+  walletAddress: external_exports3.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be 0x-prefixed 40-char hex address")
+});
+var deviceStartResponseSchema = external_exports3.object({
+  deviceCode: external_exports3.string(),
+  userCode: external_exports3.string(),
+  verificationUri: external_exports3.string(),
+  pollInterval: external_exports3.number(),
+  expiresAt: external_exports3.number()
+});
+var devicePollResponseSchema = external_exports3.union([
+  // userCode + verificationUri are optional: older API deployments don't
+  // echo them on pending.
+  external_exports3.object({
+    error: external_exports3.literal("authorization_pending"),
+    userCode: external_exports3.string().optional(),
+    verificationUri: external_exports3.string().optional()
+  }),
+  external_exports3.object({ error: external_exports3.literal("expired_token") }),
+  external_exports3.object({
+    accessToken: external_exports3.string(),
+    refreshToken: external_exports3.string(),
+    expiresIn: external_exports3.number(),
+    user: internalUserDtoSchema
   })
+]);
+var sessionExchangeResponseSchema = external_exports3.object({
+  token: external_exports3.string(),
+  expiresAt: external_exports3.number()
 });
-var BugReports = class {
-  constructor(client) {
-    this.client = client;
-  }
-  // POST /v1/bug-reports. Wallet-attributed server-side; the SDK client's
-  // active credential drives attribution (account-mode → EIP-191 from the
-  // wallet, session-mode → Bearer + server resolves the user's wallet).
-  create = (input, opts = {}) => request2(
-    this.client,
-    {
+var refreshResponseSchema = external_exports3.object({
+  accessToken: external_exports3.string(),
+  refreshToken: external_exports3.string()
+});
+var tryRefreshSession = async (client, callerSignal) => {
+  const credentials = client.getCredentials();
+  if (credentials.kind !== "session") return false;
+  if (!credentials.refreshToken) return false;
+  const url4 = `${client.baseUrl.replace(/\/$/, "")}/v1/auth/refresh`;
+  const timeoutSignal = AbortSignal.timeout(client.timeout);
+  const signal = callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
+  let response;
+  try {
+    response = await client.fetchImpl(url4, {
       method: "POST",
-      path: "/v1/bug-reports",
-      body: input,
-      signal: opts.signal
-    },
-    createBugReportResponseSchema
-  );
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ refreshToken: credentials.refreshToken }),
+      signal
+    });
+  } catch {
+    return false;
+  }
+  if (!response.ok) return false;
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return false;
+  }
+  const parsed = refreshResponseSchema.safeParse(body);
+  if (!parsed.success) return false;
+  await client.applyRefreshedTokens({
+    accessToken: parsed.data.accessToken,
+    refreshToken: parsed.data.refreshToken
+  });
+  return true;
 };
-var ratingSchema = external_exports3.object({
-  score: external_exports3.string(),
-  successRate: external_exports3.string(),
-  reviews: external_exports3.number(),
-  stars: external_exports3.string().nullable().optional(),
-  state: external_exports3.enum(["unrated", "rated"]).optional()
-});
-var capabilityResponseSchema = external_exports3.object({
-  uid: external_exports3.string(),
-  slug: external_exports3.string(),
-  name: external_exports3.string(),
-  description: external_exports3.string(),
-  url: external_exports3.string(),
-  urlTemplate: external_exports3.string().nullable().optional(),
-  method: external_exports3.string(),
-  headers: external_exports3.record(external_exports3.string(), external_exports3.string()).nullable(),
-  bodySchema: external_exports3.record(external_exports3.string(), external_exports3.unknown()).nullable(),
-  responseSchema: external_exports3.record(external_exports3.string(), external_exports3.unknown()).nullable(),
-  example: external_exports3.object({ request: external_exports3.unknown(), response: external_exports3.unknown() }).nullable(),
-  tags: external_exports3.array(external_exports3.string()).nullable(),
-  exampleAgentPrompt: external_exports3.string().nullable().optional(),
-  displayCostAmount: external_exports3.string(),
-  displayCostAsset: external_exports3.string(),
-  reviewCount: external_exports3.number(),
-  rating: ratingSchema,
-  priceObserved: external_exports3.object({
-    minCents: external_exports3.string().nullable(),
-    medianCents: external_exports3.string().nullable(),
-    maxCents: external_exports3.string().nullable(),
-    // Deprecated alias for maxCents; kept for back-compat with older
-    // API versions that still emit it.
-    p95Cents: external_exports3.string().nullable(),
-    sampleCount: external_exports3.number(),
-    varies: external_exports3.boolean(),
-    failureChargeRate: external_exports3.number().nullable()
-  }).nullable().optional(),
-  paymentMethods: external_exports3.array(
-    external_exports3.object({
-      uid: external_exports3.string(),
-      protocol: external_exports3.string(),
-      methodType: external_exports3.string(),
-      chain: external_exports3.string().nullable(),
-      mode: external_exports3.string(),
-      costAmount: external_exports3.string(),
-      costPer: external_exports3.string(),
-      priority: external_exports3.number()
-    })
-  ).nullable(),
-  availabilityStatus: external_exports3.enum(["healthy", "unknown", "down"]).nullable().optional(),
-  /**
-   * @deprecated The API no longer emits `displayStatus`; it has been replaced
-   * by the consolidated 3-value {@link capabilityResponseSchema.shape.availabilityStatus}.
-   * Kept as an optional field for one release for back-compat (ZERO-89 soft
-   * migration) and will be removed in the next major version.
-   */
-  displayStatus: external_exports3.enum(["healthy", "stable", "degraded", "unhealthy", "unknown"]).optional(),
-  activationCount: external_exports3.number().optional(),
-  lastUsedAt: external_exports3.string().nullable().optional(),
-  lastSuccessfullyRanAt: external_exports3.string().nullable().optional()
+var buildSessionAuthHeaders = (accessToken) => ({
+  authorization: `Bearer ${accessToken}`
 });
-var resolveCapabilityResponseSchema = external_exports3.object({
-  capabilityId: external_exports3.string(),
-  capabilitySlug: external_exports3.string(),
-  matchedVia: external_exports3.enum(["exact", "template"])
+var buildCanonicalMessage = (method, pathWithQuery, body, timestamp, nonce2) => {
+  const bodyHash = createHash("sha256").update(body ?? "").digest("hex");
+  return `${method}:${pathWithQuery}:${bodyHash}:${timestamp}:${nonce2}`;
+};
+var buildAccountAuthHeaders = async (account, method, pathWithQuery, body) => {
+  const timestamp = Math.floor(Date.now() / 1e3).toString();
+  const nonce2 = crypto.randomUUID();
+  const message2 = buildCanonicalMessage(
+    method,
+    pathWithQuery,
+    body,
+    timestamp,
+    nonce2
+  );
+  const signature2 = await account.signMessage({ message: message2 });
+  return {
+    "x-zero-address": account.address,
+    "x-zero-timestamp": timestamp,
+    "x-zero-nonce": nonce2,
+    "x-zero-signature": signature2
+  };
+};
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 502, 503, 504]);
+var sleep2 = (ms, signal) => new Promise((resolve6, reject) => {
+  if (signal?.aborted) {
+    reject(new DOMException("Aborted", "AbortError"));
+    return;
+  }
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve6();
+  }, ms);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(new DOMException("Aborted", "AbortError"));
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
 });
-var Capabilities = class {
+var buildPathWithQuery = (path3, query) => {
+  const normalizedPath = path3.startsWith("/") ? path3 : `/${path3}`;
+  if (!query) return normalizedPath;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0) params.set(key, String(value));
+  }
+  const qs = params.toString();
+  return qs ? `${normalizedPath}?${qs}` : normalizedPath;
+};
+var joinUrl = (baseUrl, pathWithQuery) => {
+  const base3 = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  return `${base3}${pathWithQuery}`;
+};
+var buildHeaders = async (client, method, pathWithQuery, hasBody, bodyStr) => {
+  const headers = { ...client.defaultHeaders };
+  if (hasBody) headers["content-type"] = "application/json";
+  headers["x-zero-sdk-version"] = SDK_VERSION2;
+  if (client.apiVersion) headers["x-zero-api-version"] = client.apiVersion;
+  const credentials = client.getCredentials();
+  if (credentials.kind === "session") {
+    Object.assign(headers, buildSessionAuthHeaders(credentials.accessToken));
+  } else if (credentials.kind === "account") {
+    const signed = await buildAccountAuthHeaders(
+      credentials.account,
+      method,
+      pathWithQuery,
+      bodyStr
+    );
+    Object.assign(headers, signed);
+  }
+  return headers;
+};
+var parseErrorBody = async (response) => {
+  try {
+    return await response.clone().json();
+  } catch {
+    try {
+      return await response.text();
+    } catch {
+      return void 0;
+    }
+  }
+};
+var errorMessageFromBody = (body, status) => {
+  if (body !== null && typeof body === "object" && "error" in body && typeof body.error === "string") {
+    return body.error;
+  }
+  return `HTTP ${status}`;
+};
+var request2 = async (client, opts, schema) => {
+  const pathWithQuery = buildPathWithQuery(opts.path, opts.query);
+  const url4 = joinUrl(client.baseUrl, pathWithQuery);
+  const hasBody = opts.body !== void 0;
+  const bodyStr = hasBody ? JSON.stringify(
+    opts.body,
+    (_k, v) => typeof v === "bigint" ? v.toString() : v
+  ) : void 0;
+  const configuredFetch = buildConfiguredFetch(client);
+  const performOnce = async () => configuredFetch(url4, {
+    method: opts.method,
+    headers: await buildHeaders(
+      client,
+      opts.method,
+      pathWithQuery,
+      hasBody,
+      bodyStr
+    ),
+    body: bodyStr,
+    signal: opts.signal
+  });
+  let refreshAttempted = false;
+  const executeWithRefresh = async () => {
+    const response = await performOnce();
+    if (response.status !== 401 || refreshAttempted) return response;
+    const credentials = client.getCredentials();
+    if (credentials.kind !== "session") return response;
+    refreshAttempted = true;
+    const refreshed = await client.refreshSessionOnce(opts.signal);
+    if (!refreshed) return response;
+    return await performOnce();
+  };
+  let lastNetworkError;
+  for (let attempt = 0; attempt <= client.maxRetries; attempt++) {
+    let response;
+    try {
+      response = await executeWithRefresh();
+    } catch (e2) {
+      if (e2 instanceof ZeroError) throw e2;
+      lastNetworkError = e2;
+      if (attempt < client.maxRetries) {
+        try {
+          await sleep2(2 ** attempt * 200, opts.signal);
+        } catch (sleepErr) {
+          throw new ZeroApiError("Request aborted by caller", {
+            status: 0,
+            cause: sleepErr
+          });
+        }
+        continue;
+      }
+      throw new ZeroApiError("Network request failed", {
+        status: 0,
+        cause: e2
+      });
+    }
+    if (response.ok) {
+      let text;
+      try {
+        text = await response.text();
+      } catch (e2) {
+        throw new ZeroApiError("Response body read failed", {
+          status: response.status,
+          cause: e2
+        });
+      }
+      let json3;
+      try {
+        json3 = JSON.parse(text);
+      } catch {
+      }
+      const parsed = schema.safeParse(json3);
+      if (!parsed.success) {
+        throw new ZeroValidationError(
+          `Response did not match expected schema for ${opts.method} ${opts.path}`,
+          { cause: parsed.error, body: text }
+        );
+      }
+      return parsed.data;
+    }
+    if (RETRYABLE_STATUS.has(response.status) && attempt < client.maxRetries) {
+      try {
+        await sleep2(2 ** attempt * 200, opts.signal);
+      } catch (sleepErr) {
+        throw new ZeroApiError("Request aborted by caller", {
+          status: 0,
+          cause: sleepErr
+        });
+      }
+      continue;
+    }
+    const errorBody = await parseErrorBody(response);
+    const requestId = response.headers.get("x-request-id") ?? void 0;
+    throw new ZeroApiError(errorMessageFromBody(errorBody, response.status), {
+      status: response.status,
+      requestId,
+      body: errorBody
+    });
+  }
+  throw new ZeroApiError("Exhausted retries", {
+    status: 0,
+    cause: lastNetworkError
+  });
+};
+var AuthDevice = class {
   constructor(client) {
     this.client = client;
   }
-  get = (id, opts = {}) => request2(
+  start = (opts = {}) => request2(
     this.client,
     {
-      method: "GET",
-      path: `/v1/capabilities/${encodeURIComponent(id)}`,
-      query: opts.searchId ? { searchId: opts.searchId } : void 0,
+      method: "POST",
+      path: "/v1/auth/device/start",
       signal: opts.signal
     },
-    capabilityResponseSchema
+    deviceStartResponseSchema
   );
-  // Resolve a raw endpoint URL + method back to the capability that owns it,
-  // for the `zero fetch <url>` case where the client has no local search
-  // context to match against (a memoized/cross-session URL). Returns null on
-  // 404 — i.e. no match or an ambiguous multi-match, both of which the server
-  // reports as 404 (resolveByUrl fails closed rather than mis-attribute).
-  // The URL travels in the POST body so it stays out of access logs and is
-  // never stored; the caller uses the returned capabilityId to record an
-  // attributed run without the URL ever touching the run row (ZERO-335).
-  resolveByUrl = async (url4, method, opts = {}) => {
-    try {
-      return await request2(
-        this.client,
-        {
-          method: "POST",
-          path: "/v1/capabilities/resolve",
-          body: { url: url4, method },
-          signal: opts.signal
-        },
-        resolveCapabilityResponseSchema
-      );
-    } catch (err) {
-      if (err instanceof ZeroApiError && err.status === 404) return null;
-      throw err;
+  poll = async (deviceCode, opts = {}) => {
+    const parsed = await request2(
+      this.client,
+      {
+        method: "POST",
+        path: "/v1/auth/device/poll",
+        body: { deviceCode },
+        signal: opts.signal
+      },
+      devicePollResponseSchema
+    );
+    if ("error" in parsed) {
+      return parsed.error === "authorization_pending" ? {
+        status: "pending",
+        userCode: parsed.userCode,
+        verificationUri: parsed.verificationUri
+      } : { status: "expired" };
     }
+    return {
+      status: "ok",
+      accessToken: parsed.accessToken,
+      refreshToken: parsed.refreshToken,
+      expiresIn: parsed.expiresIn,
+      user: parsed.user
+    };
   };
 };
-var createRunResponseSchema = external_exports3.object({
-  runId: external_exports3.string()
-});
-var runListItemSchema = external_exports3.object({
-  uid: external_exports3.string(),
-  capabilityUid: external_exports3.string(),
-  capabilitySlug: external_exports3.string(),
-  capabilityName: external_exports3.string(),
-  status: external_exports3.number().nullable(),
-  latencyMs: external_exports3.number().nullable(),
-  cost: external_exports3.object({ amount: external_exports3.string(), asset: external_exports3.string().nullable() }).nullable(),
-  payment: external_exports3.object({
-    protocol: external_exports3.string(),
-    chain: external_exports3.string().nullable(),
-    txHash: external_exports3.string().nullable(),
-    mode: external_exports3.string().nullable()
-  }).nullable(),
-  createdAt: external_exports3.coerce.date(),
-  reviewed: external_exports3.boolean()
-});
+var userWalletsSchema = external_exports3.array(userWalletDtoSchema);
+var normalizeMessage = (message2) => {
+  if (typeof message2 === "string") return message2;
+  if (typeof message2.raw === "string") return message2.raw;
+  return bytesToHex(message2.raw);
+};
+var repackageSignFailure = (err, op) => {
+  if (err instanceof ZeroApiError && err.status === 402) {
+    const body = err.body;
+    const detail = body && typeof body.error === "string" ? `: ${body.error}` : "";
+    throw new ZeroPaymentError(
+      `Sign endpoint refused ${op} (HTTP 402)${detail}`,
+      { cause: err }
+    );
+  }
+  throw err;
+};
+var Auth = class {
+  constructor(client) {
+    this.client = client;
+    this.device = new AuthDevice(client);
+  }
+  device;
+  // The internal (web-app facing) user profile. Richer than profile(): full
+  // wallet list with per-wallet delegation/signer/limit metadata.
+  me = (opts = {}) => request2(
+    this.client,
+    { method: "GET", path: "/v1/users/me", signal: opts.signal },
+    internalUserDtoSchema
+  );
+  // The public (agent-facing) profile — identity + primary wallet address +
+  // balance + welcome-bonus, no per-wallet metadata. Same shape the MCP
+  // get_profile tool returns; rendered by `zero auth whoami`.
+  profile = (opts = {}) => request2(
+    this.client,
+    { method: "GET", path: "/v1/users/me/profile", signal: opts.signal },
+    publicUserDtoSchema
+  );
+  // The user's wallets only. Lightweight sibling of `me()` for callers that
+  // just need wallet addresses (e.g. managed-account resolution on the pay
+  // path) — avoids the heavier internal-profile computation behind `me()`.
+  wallets = (opts = {}) => request2(
+    this.client,
+    { method: "GET", path: "/v1/users/me/wallets", signal: opts.signal },
+    userWalletsSchema
+  );
+  // Exchange an ephemeral session code (e.g. runner / sandbox handoff) for
+  // a session access token. The returned token has no refresh path — pair
+  // with `refreshToken: ""` when constructing the client.
+  exchangeSessionCode = (code, opts = {}) => request2(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/session/exchange",
+      body: { code },
+      signal: opts.signal
+    },
+    sessionExchangeResponseSchema
+  );
+  // Server-side revoke of the refresh token. Throws ZeroApiError on any
+  // non-2xx — callers that have already cleared local state (e.g. CLI
+  // logout) typically want to swallow with `.catch(() => {})` so a flaky
+  // server doesn't surface as a user-visible failure for a sign-out that
+  // already succeeded locally. Response body is opaque; schema is
+  // `z.unknown()` and the resolved value is discarded.
+  logout = async (refreshToken, opts = {}) => {
+    await request2(
+      this.client,
+      {
+        method: "POST",
+        path: "/v1/auth/logout",
+        body: { refreshToken },
+        signal: opts.signal
+      },
+      external_exports3.unknown()
+    );
+  };
+  // Force a session refresh. Routes through refreshSessionOnce() so a
+  // proactive call doesn't race a 401-driven transport refresh —
+  // concurrent POSTs with the same refresh token kill the session
+  // family (RFC 6819 token-theft response).
+  refresh = async () => {
+    const credentials = this.client.getCredentials();
+    if (credentials.kind !== "session") {
+      throw new ZeroAuthError(
+        "auth_no_credentials",
+        "refresh() requires the client to be constructed with a session \u2014 got credentials.kind=" + credentials.kind
+      );
+    }
+    const ok = await this.client.refreshSessionOnce();
+    if (!ok) {
+      throw new ZeroAuthError(
+        "auth_session_expired",
+        "Session refresh failed. The refresh token may be revoked or expired."
+      );
+    }
+  };
+  signMessage = async (input, opts = {}) => {
+    const credentials = this.client.getCredentials();
+    if (credentials.kind === "account") {
+      return await credentials.account.signMessage({ message: input.message });
+    }
+    if (credentials.kind === "session") {
+      try {
+        const parsed = await request2(
+          this.client,
+          {
+            method: "POST",
+            path: "/v1/users/me/sign-message",
+            body: { message: normalizeMessage(input.message) }
+          },
+          signResponseSchema
+        );
+        this.assertSignerMatches(parsed.walletAddress, opts.expectedAddress);
+        return parsed.signature;
+      } catch (err) {
+        repackageSignFailure(err, "signMessage");
+      }
+    }
+    throw new ZeroAuthError(
+      "auth_no_credentials",
+      "signMessage() requires the client to be constructed with `account` or `session`."
+    );
+  };
+  // Managed-only: BYO accounts sign locally via viem's account.signTransaction.
+  signTransaction = async (input, opts = {}) => {
+    const credentials = this.client.getCredentials();
+    if (credentials.kind === "session") {
+      try {
+        const parsed = await request2(
+          this.client,
+          {
+            method: "POST",
+            path: "/v1/users/me/sign-transaction",
+            body: { unsignedTransaction: input.unsignedTransaction }
+          },
+          signResponseSchema
+        );
+        this.assertSignerMatches(parsed.walletAddress, opts.expectedAddress);
+        return parsed.signature;
+      } catch (err) {
+        repackageSignFailure(err, "signTransaction");
+      }
+    }
+    if (credentials.kind === "account") {
+      throw new ZeroAuthError(
+        "auth_error",
+        "signTransaction() is a managed-signing operation and is not supported in account mode. Sign locally with viem's account.signTransaction instead."
+      );
+    }
+    throw new ZeroAuthError(
+      "auth_no_credentials",
+      "signTransaction() requires session credentials (managed signing)."
+    );
+  };
+  signTypedData = async (input, opts = {}) => {
+    const credentials = this.client.getCredentials();
+    if (credentials.kind === "account") {
+      if (!credentials.account.signTypedData) {
+        throw new ZeroAuthError(
+          "auth_error",
+          "The configured viem account does not implement signTypedData."
+        );
+      }
+      return await credentials.account.signTypedData(input);
+    }
+    if (credentials.kind === "session") {
+      try {
+        const parsed = await request2(
+          this.client,
+          {
+            method: "POST",
+            path: "/v1/users/me/sign-typed-data",
+            body: { typedData: input }
+          },
+          signResponseSchema
+        );
+        this.assertSignerMatches(parsed.walletAddress, opts.expectedAddress);
+        return parsed.signature;
+      } catch (err) {
+        repackageSignFailure(err, "signTypedData");
+      }
+    }
+    throw new ZeroAuthError(
+      "auth_no_credentials",
+      "signTypedData() requires the client to be constructed with `account` or `session`."
+    );
+  };
+  // Compare against the caller's pinned address (not shared cache) so
+  // concurrent pay()s can't race past each other. Mismatch → clear + throw;
+  // the caller's retry rebuilds against the new wallet.
+  assertSignerMatches = (serverAddr, expectedAddr) => {
+    if (!expectedAddr) return;
+    const canonicalServer = getAddress(serverAddr);
+    const canonicalExpected = getAddress(expectedAddr);
+    if (canonicalExpected === canonicalServer) return;
+    this.client.clearManagedAccount();
+    throw new ZeroAuthError(
+      "auth_error",
+      `Managed signing wallet changed (caller expected ${canonicalExpected}, server signed as ${canonicalServer}). Cache cleared \u2014 retry to rebuild against the current wallet.`
+    );
+  };
+};
+var BUG_REPORT_CATEGORIES = [
+  "search_relevance",
+  "ranking_issue",
+  "missing_capability",
+  "wrong_schema",
+  "misleading_description",
+  "broken_execution",
+  "payment_failure",
+  "billing_anomaly",
+  "cli_bug",
+  "security",
+  "other"
+];
+var createBugReportResponseSchema = external_exports3.object({
+  bugReportId: external_exports3.string(),
+  status: external_exports3.string(),
+  deduped: external_exports3.boolean(),
+  category: external_exports3.enum(BUG_REPORT_CATEGORIES).nullable(),
+  title: external_exports3.string().nullable(),
+  attached: external_exports3.object({
+    capabilityId: external_exports3.number().nullable(),
+    runId: external_exports3.number().nullable(),
+    searchId: external_exports3.number().nullable()
+  })
+});
+var BugReports = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // POST /v1/bug-reports. Wallet-attributed server-side; the SDK client's
+  // active credential drives attribution (account-mode → EIP-191 from the
+  // wallet, session-mode → Bearer + server resolves the user's wallet).
+  create = (input, opts = {}) => request2(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/bug-reports",
+      body: input,
+      signal: opts.signal
+    },
+    createBugReportResponseSchema
+  );
+};
+var ratingSchema = external_exports3.object({
+  score: external_exports3.string(),
+  successRate: external_exports3.string(),
+  reviews: external_exports3.number(),
+  stars: external_exports3.string().nullable().optional(),
+  state: external_exports3.enum(["unrated", "rated"]).optional()
+});
+var capabilityResponseSchema = external_exports3.object({
+  uid: external_exports3.string(),
+  slug: external_exports3.string(),
+  name: external_exports3.string(),
+  description: external_exports3.string(),
+  url: external_exports3.string(),
+  urlTemplate: external_exports3.string().nullable().optional(),
+  method: external_exports3.string(),
+  headers: external_exports3.record(external_exports3.string(), external_exports3.string()).nullable(),
+  bodySchema: external_exports3.record(external_exports3.string(), external_exports3.unknown()).nullable(),
+  responseSchema: external_exports3.record(external_exports3.string(), external_exports3.unknown()).nullable(),
+  example: external_exports3.object({ request: external_exports3.unknown(), response: external_exports3.unknown() }).nullable(),
+  tags: external_exports3.array(external_exports3.string()).nullable(),
+  exampleAgentPrompt: external_exports3.string().nullable().optional(),
+  displayCostAmount: external_exports3.string(),
+  displayCostAsset: external_exports3.string(),
+  reviewCount: external_exports3.number(),
+  rating: ratingSchema,
+  priceObserved: external_exports3.object({
+    minCents: external_exports3.string().nullable(),
+    medianCents: external_exports3.string().nullable(),
+    maxCents: external_exports3.string().nullable(),
+    // Deprecated alias for maxCents; kept for back-compat with older
+    // API versions that still emit it.
+    p95Cents: external_exports3.string().nullable(),
+    sampleCount: external_exports3.number(),
+    varies: external_exports3.boolean(),
+    failureChargeRate: external_exports3.number().nullable()
+  }).nullable().optional(),
+  paymentMethods: external_exports3.array(
+    external_exports3.object({
+      uid: external_exports3.string(),
+      protocol: external_exports3.string(),
+      methodType: external_exports3.string(),
+      chain: external_exports3.string().nullable(),
+      mode: external_exports3.string(),
+      costAmount: external_exports3.string(),
+      costPer: external_exports3.string(),
+      priority: external_exports3.number()
+    })
+  ).nullable(),
+  availabilityStatus: external_exports3.enum(["healthy", "unknown", "down"]).nullable().optional(),
+  /**
+   * @deprecated The API no longer emits `displayStatus`; it has been replaced
+   * by the consolidated 3-value {@link capabilityResponseSchema.shape.availabilityStatus}.
+   * Kept as an optional field for one release for back-compat (ZERO-89 soft
+   * migration) and will be removed in the next major version.
+   */
+  displayStatus: external_exports3.enum(["healthy", "stable", "degraded", "unhealthy", "unknown"]).optional(),
+  activationCount: external_exports3.number().optional(),
+  lastUsedAt: external_exports3.string().nullable().optional(),
+  lastSuccessfullyRanAt: external_exports3.string().nullable().optional()
+});
+var resolveCapabilityResponseSchema = external_exports3.object({
+  capabilityId: external_exports3.string(),
+  capabilitySlug: external_exports3.string(),
+  matchedVia: external_exports3.enum(["exact", "template"])
+});
+var Capabilities = class {
+  constructor(client) {
+    this.client = client;
+  }
+  get = (id, opts = {}) => request2(
+    this.client,
+    {
+      method: "GET",
+      path: `/v1/capabilities/${encodeURIComponent(id)}`,
+      query: opts.searchId ? { searchId: opts.searchId } : void 0,
+      signal: opts.signal
+    },
+    capabilityResponseSchema
+  );
+  // Resolve a raw endpoint URL + method back to the capability that owns it,
+  // for the `zero fetch <url>` case where the client has no local search
+  // context to match against (a memoized/cross-session URL). Returns null on
+  // 404 — i.e. no match or an ambiguous multi-match, both of which the server
+  // reports as 404 (resolveByUrl fails closed rather than mis-attribute).
+  // The URL travels in the POST body so it stays out of access logs and is
+  // never stored; the caller uses the returned capabilityId to record an
+  // attributed run without the URL ever touching the run row (ZERO-335).
+  resolveByUrl = async (url4, method, opts = {}) => {
+    try {
+      return await request2(
+        this.client,
+        {
+          method: "POST",
+          path: "/v1/capabilities/resolve",
+          body: { url: url4, method },
+          signal: opts.signal
+        },
+        resolveCapabilityResponseSchema
+      );
+    } catch (err) {
+      if (err instanceof ZeroApiError && err.status === 404) return null;
+      throw err;
+    }
+  };
+};
+var createRunResponseSchema = external_exports3.object({
+  runId: external_exports3.string()
+});
+var runListItemSchema = external_exports3.object({
+  uid: external_exports3.string(),
+  capabilityUid: external_exports3.string(),
+  capabilitySlug: external_exports3.string(),
+  capabilityName: external_exports3.string(),
+  status: external_exports3.number().nullable(),
+  latencyMs: external_exports3.number().nullable(),
+  cost: external_exports3.object({ amount: external_exports3.string(), asset: external_exports3.string().nullable() }).nullable(),
+  payment: external_exports3.object({
+    protocol: external_exports3.string(),
+    chain: external_exports3.string().nullable(),
+    txHash: external_exports3.string().nullable(),
+    mode: external_exports3.string().nullable()
+  }).nullable(),
+  createdAt: external_exports3.coerce.date(),
+  reviewed: external_exports3.boolean()
+});
 var listRunsResponseSchema = external_exports3.object({
   runs: external_exports3.array(runListItemSchema),
   nextCursor: external_exports3.string().nullable()
@@ -144935,886 +145557,271 @@ var Runs = class {
   }
   create = (input, opts = {}) => request2(
     this.client,
-    {
-      method: "POST",
-      path: "/v1/runs",
-      body: input,
-      signal: opts.signal
-    },
-    createRunResponseSchema
-  );
-  list = (params = {}, opts = {}) => {
-    if (params.limit === 0) {
-      if (opts.signal?.aborted) {
-        return Promise.reject(
-          new ZeroApiError("Request aborted by caller", { status: 0 })
-        );
-      }
-      if (params.cursor === void 0) {
-        return Promise.reject(
-          new ZeroApiError(
-            "runs.list({ limit: 0 }) requires a cursor \u2014 without one the empty page is indistinguishable from end-of-stream",
-            { status: 0 }
-          )
-        );
-      }
-      return Promise.resolve({
-        runs: [],
-        nextCursor: params.cursor
-      });
-    }
-    const query = {};
-    if (params.capabilityId !== void 0)
-      query.capabilityId = params.capabilityId;
-    if (params.unreviewed !== void 0) query.unreviewed = params.unreviewed;
-    if (params.limit !== void 0) query.limit = params.limit;
-    if (params.cursor !== void 0) query.cursor = params.cursor;
-    return request2(
-      this.client,
-      {
-        method: "GET",
-        path: "/v1/runs",
-        query,
-        signal: opts.signal
-      },
-      listRunsResponseSchema
-    );
-  };
-  get = (runId, opts = {}) => request2(
-    this.client,
-    {
-      method: "GET",
-      path: `/v1/runs/${runId}`,
-      signal: opts.signal
-    },
-    runDetailSchema
-  );
-  review = (input, opts = {}) => request2(
-    this.client,
-    {
-      method: "POST",
-      path: "/v1/reviews",
-      body: input,
-      signal: opts.signal
-    },
-    createReviewResponseSchema
-  );
-  // Bulk review submission. The CLI's bulk JSONL parser stays CLI-side —
-  // SDK consumers pass already-parsed structured input.
-  createReviewsBatch = (reviews, opts = {}) => request2(
-    this.client,
-    {
-      method: "POST",
-      path: "/v1/reviews/batch",
-      body: { reviews },
-      signal: opts.signal
-    },
-    batchReviewResponseSchema
-  );
-};
-var USDC_BASE2 = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
-var USDC_TEMPO2 = "0x20c000000000000000000000b9537d11c60e8b50";
-var TEMPO_CHAIN_ID2 = 4217;
-var baseChain = base;
-var tempoChain2 = {
-  id: TEMPO_CHAIN_ID2,
-  name: "Tempo",
-  nativeCurrency: { name: "USD", symbol: "USD", decimals: 18 },
-  rpcUrls: {
-    default: { http: ["https://rpc.tempo.xyz"] }
-  }
-};
-var ERC20_BALANCE_ABI2 = [
-  {
-    inputs: [{ name: "account", type: "address" }],
-    name: "balanceOf",
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
-  }
-];
-var USDC_DECIMALS = 6;
-var fundingUrlResponseSchema = external_exports3.object({ url: external_exports3.string() });
-var userWalletListSchema = external_exports3.array(userWalletDtoSchema);
-var migrateAuthorizationResponseSchema = external_exports3.object({
-  transactionHash: external_exports3.string()
-});
-var errorMessage = (reason) => reason instanceof Error ? reason.message : String(reason);
-var Wallet = class {
-  constructor(client) {
-    this.client = client;
-  }
-  clients = {};
-  // The configured wallet address, or null if the client wasn't constructed
-  // with an account. Stable read — does not hit the network.
-  get address() {
-    const credentials = this.client.getCredentials();
-    if (credentials.kind !== "account") return null;
-    return credentials.account.address;
-  }
-  balance = async (opts = {}) => {
-    const target = opts.address ?? this.address;
-    if (!target) {
-      throw new ZeroWalletError(
-        "balance() requires either an `address` option or a client constructed with an account"
-      );
-    }
-    const chain2 = opts.chain ?? "total";
-    if (chain2 !== "total") {
-      const raw = await this.readChainBalance(chain2, target);
-      return { amount: formatUnits(raw, USDC_DECIMALS), asset: "USDC" };
-    }
-    const chains = ["base", "tempo"];
-    const settled = await Promise.allSettled(
-      chains.map((c) => this.readChainBalance(c, target))
-    );
-    let sum = 0n;
-    const errors = [];
-    for (let i = 0; i < settled.length; i++) {
-      const result = settled[i];
-      const chainName = chains[i];
-      if (!result || !chainName) continue;
-      if (result.status === "fulfilled") {
-        sum += result.value;
-      } else {
-        errors.push({ chain: chainName, message: errorMessage(result.reason) });
-      }
-    }
-    if (errors.length === settled.length) {
-      throw new ZeroWalletError(
-        `balance() failed for every chain: ${errors.map((e2) => `${e2.chain} (${e2.message})`).join(", ")}`
-      );
-    }
-    const balance = {
-      amount: formatUnits(sum, USDC_DECIMALS),
-      asset: "USDC"
-    };
-    if (errors.length > 0) balance.errors = errors;
-    return balance;
-  };
-  // All wallets linked to the authenticated session user. Session-only.
-  list = (opts = {}) => request2(
-    this.client,
-    {
-      method: "GET",
-      path: "/v1/users/me/wallets",
-      signal: opts.signal
-    },
-    userWalletListSchema
-  );
-  // Provision a managed (Privy-embedded) wallet for the session user.
-  // Idempotent server-side — repeat calls return the existing wallet.
-  provision = (opts = {}) => request2(
-    this.client,
-    {
-      method: "POST",
-      path: "/v1/users/me/wallets/provision",
-      signal: opts.signal
-    },
-    userWalletDtoSchema
-  );
-  // Relays a BYO-wallet-signed EIP-3009 ReceiveWithAuthorization, sweeping
-  // USDC from the BYO wallet to the user's Zero wallet on Base via the
-  // gas-paying relayer. The SDK does not author the authorization (chain
-  // nonce + EIP-712 domain coupling stays caller-side); it only forwards
-  // the signed payload. Session-only.
-  migrateAuthorization = (authorization, opts = {}) => request2(
-    this.client,
-    {
-      method: "POST",
-      path: "/v1/users/me/wallets/migrate",
-      body: { authorization },
-      signal: opts.signal
-    },
-    migrateAuthorizationResponseSchema
-  );
-  // Routes by identity: account mode signs EIP-191 against /v1/wallet/fund-url,
-  // session mode hits /v1/users/me/fund-url (Bearer-authed, wallet resolved
-  // server-side). Both honor `provider` (coinbase | stripe).
-  fundingUrl = async (opts = {}) => {
-    const credentials = this.client.getCredentials();
-    const path3 = credentials.kind === "account" ? "/v1/wallet/fund-url" : credentials.kind === "session" ? "/v1/users/me/fund-url" : null;
-    if (!path3) {
-      throw new ZeroWalletError(
-        "fundingUrl() requires a client constructed with an account or session credentials"
-      );
-    }
-    const query = {
-      provider: opts.provider ?? "coinbase"
-    };
-    if (opts.amount) query.amount = opts.amount;
-    const { url: url4 } = await request2(
-      this.client,
-      { method: "GET", path: path3, query, signal: opts.signal },
-      fundingUrlResponseSchema
-    );
-    return url4;
-  };
-  getPublicClient = (chain2) => {
-    if (chain2 === "base") {
-      if (!this.clients.base) {
-        this.clients.base = createPublicClient({
-          chain: baseChain,
-          transport: http()
-        });
-      }
-      return this.clients.base;
-    }
-    if (!this.clients.tempo) {
-      this.clients.tempo = createPublicClient({
-        // biome-ignore lint/suspicious/noExplicitAny: tempo is a custom chain object that viem's stricter Chain type rejects shape-wise but accepts at runtime
-        chain: tempoChain2,
-        transport: http()
-      });
-    }
-    return this.clients.tempo;
-  };
-  /**
-   * @internal
-   *
-   * Per-chain USDC balance read. Exposed (rather than private) so unit
-   * tests can stub it without standing up a real viem public client —
-   * viem's `http()` transport doesn't go through `client.fetchImpl`, so
-   * the standard mock-fetch trick doesn't cover this path.
-   */
-  readChainBalance = async (chain2, address2) => {
-    const publicClient = this.getPublicClient(chain2);
-    const tokenAddress = chain2 === "base" ? USDC_BASE2 : USDC_TEMPO2;
-    const balance = await publicClient.readContract({
-      address: tokenAddress,
-      abi: ERC20_BALANCE_ABI2,
-      functionName: "balanceOf",
-      args: [address2]
-    });
-    return balance;
-  };
-};
-var DEFAULT_BASE_URL = "https://api.zero.xyz";
-var DEFAULT_TIMEOUT_MS = 18e4;
-var DEFAULT_MAX_RETRIES = 2;
-var noopRefresh = async () => {
-};
-var MAX_402_PROBE_BYTES = 1024 * 1024;
-var MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
-var TEXT_CONTENT_TYPES = [
-  "application/json",
-  "application/xml",
-  "application/javascript",
-  "application/ecmascript",
-  "application/x-www-form-urlencoded",
-  "text/",
-  "+json",
-  "+xml"
-];
-var MPP_SCHEME_TOKENS = /* @__PURE__ */ new Set(["payment", "mpp"]);
-var splitWwwAuthenticateChallenges = (header) => {
-  const chunks = [];
-  let buf = "";
-  let inQuotes = false;
-  for (let i = 0; i < header.length; i++) {
-    const ch = header[i];
-    if (inQuotes) {
-      if (ch === "\\" && i + 1 < header.length) {
-        buf += ch + header[i + 1];
-        i++;
-        continue;
-      }
-      if (ch === '"') inQuotes = false;
-      buf += ch;
-      continue;
-    }
-    if (ch === '"') {
-      inQuotes = true;
-      buf += ch;
-      continue;
-    }
-    if (ch === ",") {
-      chunks.push(buf);
-      buf = "";
-      continue;
-    }
-    buf += ch;
-  }
-  if (buf.length > 0) chunks.push(buf);
-  return chunks;
-};
-var isTextContentType = (contentType) => {
-  if (!contentType) return true;
-  const lower = contentType.toLowerCase();
-  return TEXT_CONTENT_TYPES.some((marker) => lower.includes(marker));
-};
-var redactUrl2 = (url4) => {
-  try {
-    const u2 = new URL(url4);
-    return `${u2.origin}${u2.pathname}`;
-  } catch {
-    return "<invalid url>";
-  }
-};
-var ECHO_DETECT_MIN_LEN = 16;
-var ECHO_DETECT_MAX_SCAN = 64 * 1024;
-var requestBodyEchoed = (candidate, requestBody) => {
-  if (requestBody === void 0) return false;
-  const asString = typeof requestBody === "string" ? requestBody : new TextDecoder("utf-8", { fatal: false }).decode(
-    requestBody.byteLength > ECHO_DETECT_MAX_SCAN ? requestBody.subarray(0, ECHO_DETECT_MAX_SCAN) : requestBody
-  );
-  if (asString.length < ECHO_DETECT_MIN_LEN) return false;
-  const scanLen = Math.min(asString.length, ECHO_DETECT_MAX_SCAN);
-  for (let i = 0; i + ECHO_DETECT_MIN_LEN <= scanLen; i++) {
-    if (candidate.includes(asString.slice(i, i + ECHO_DETECT_MIN_LEN))) {
-      return true;
-    }
-  }
-  return false;
-};
-var cancelBody2 = (response) => {
-  try {
-    response.body?.cancel().catch(() => {
-    });
-  } catch {
-  }
-};
-var detectPaymentRequirement = async (response) => {
-  if (response.status !== 402) return null;
-  const x402Header = response.headers.get("payment-required") ?? response.headers.get("x-payment-required");
-  if (x402Header) {
-    cancelBody2(response);
-    try {
-      const decoded = JSON.parse(
-        Buffer.from(x402Header, "base64").toString("utf8")
-      );
-      return { protocol: "x402", raw: decoded };
-    } catch {
-      return { protocol: "x402", raw: { encoded: x402Header } };
-    }
-  }
-  const declaredLen = Number.parseInt(
-    response.headers.get("content-length") ?? "",
-    10
-  );
-  const bodyFits = !Number.isFinite(declaredLen) || declaredLen <= MAX_402_PROBE_BYTES;
-  if (bodyFits) {
-    try {
-      const text = await readClippedText(response, MAX_402_PROBE_BYTES);
-      if (text) {
-        const parsed = JSON.parse(text);
-        if (looksLikeX402Body(parsed)) {
-          return { protocol: "x402", raw: parsed };
-        }
-      }
-    } catch {
-    }
-  }
-  const wwwAuth = response.headers.get("www-authenticate");
-  if (wwwAuth) {
-    const schemes = splitWwwAuthenticateChallenges(wwwAuth).map(
-      (challenge2) => challenge2.trim().split(/\s+/)[0]?.toLowerCase() ?? ""
-    );
-    if (schemes.some((scheme) => MPP_SCHEME_TOKENS.has(scheme))) {
-      cancelBody2(response);
-      return { protocol: "mpp", raw: { "www-authenticate": wwwAuth } };
-    }
-  }
-  cancelBody2(response);
-  return { protocol: "unknown", raw: {} };
-};
-var readClippedBytes = async (response, max) => {
-  if (response.body === null) return new Uint8Array(0);
-  const reader = response.body.getReader();
-  const chunks = [];
-  let total = 0;
-  try {
-    while (total < max) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (!value) continue;
-      chunks.push(value);
-      total += value.byteLength;
-    }
-  } finally {
-    try {
-      await reader.cancel();
-    } catch {
-    }
-  }
-  const merged = new Uint8Array(Math.min(total, max));
-  let offset = 0;
-  for (const c of chunks) {
-    const take = Math.min(c.byteLength, max - offset);
-    merged.set(c.subarray(0, take), offset);
-    offset += take;
-    if (offset >= max) break;
-  }
-  return merged;
-};
-var readClippedText = async (response, max) => {
-  const bytes = await readClippedBytes(response, max);
-  return new TextDecoder().decode(bytes);
-};
-var parseResponseBody = async (response, max) => {
-  const contentType = response.headers.get("content-type");
-  const bytes = await readClippedBytes(response, max + 1);
-  const truncated = bytes.byteLength > max;
-  const view = truncated ? bytes.subarray(0, max) : bytes;
-  const buf = Buffer.from(view.buffer, view.byteOffset, view.byteLength);
-  if (!isTextContentType(contentType)) {
-    const base644 = buf.toString("base64");
-    return {
-      body: base644,
-      bodyRaw: base644,
-      bodyEncoding: "base64",
-      truncated
-    };
-  }
-  const text = buf.toString("utf8");
-  if (contentType?.toLowerCase().includes("json")) {
-    try {
-      return { body: JSON.parse(text), bodyRaw: text, truncated };
-    } catch {
-    }
-  }
-  return { body: text, bodyRaw: text, truncated };
-};
-var UPSTREAM_ERROR_FIELDS = [
-  "error",
-  "message",
-  "detail",
-  "reason",
-  "error_description"
-];
-var UPSTREAM_ERROR_MAX_LEN = 200;
-var ERROR_SNIPPET_BYTES = 500;
-var clampUpstreamMessage = (value) => {
-  const trimmed = value.trim();
-  if (!trimmed) return void 0;
-  return trimmed.length > UPSTREAM_ERROR_MAX_LEN ? `${trimmed.slice(0, UPSTREAM_ERROR_MAX_LEN)}\u2026` : trimmed;
-};
-var tryParseJson = (text) => {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
-};
-var extractUpstreamErrorMessage = (body) => {
-  const parsed = tryParseJson(body);
-  if (parsed === null || typeof parsed !== "object") {
-    return clampUpstreamMessage(body);
-  }
-  const record3 = parsed;
-  for (const field of UPSTREAM_ERROR_FIELDS) {
-    const value = record3[field];
-    if (typeof value === "string" && value.length > 0) {
-      return clampUpstreamMessage(value);
-    }
-    if (value && typeof value === "object") {
-      const nested = value.message;
-      if (typeof nested === "string" && nested.length > 0) {
-        return clampUpstreamMessage(nested);
-      }
-    }
-  }
-  return void 0;
-};
-var buildUpstreamError = (status, bodyRaw, bodyEncoding) => {
-  if (status >= 200 && status < 300) return void 0;
-  if (bodyRaw === null || bodyRaw.length === 0) return void 0;
-  if (bodyEncoding === "base64") return void 0;
-  const snippet = bodyRaw.slice(0, ERROR_SNIPPET_BYTES);
-  return {
-    status,
-    message: extractUpstreamErrorMessage(bodyRaw),
-    snippetHash: createHash("sha256").update(snippet).digest("hex"),
-    snippetLength: snippet.length
-  };
-};
-var computeOutcome = (status, payment, warnings) => {
-  if (warnings.includes(FETCH_WARNINGS.mppSessionCloseFailed))
-    return "payment_close_failed";
-  if (status === 402 && payment !== null) return "payment_rejected";
-  if (status === 402) return "payment_failed";
-  if (status >= 400) return "server_error";
-  return "success";
-};
-var errorFetchResult = (startedAt, error48, skipReason, capabilityIdRequested, outcome, status = null) => {
-  const result = {
-    runId: null,
-    ok: false,
-    status,
-    latencyMs: Date.now() - startedAt,
-    payment: null,
-    outcome,
-    body: null,
-    bodyRaw: null,
-    error: error48
-  };
-  if (capabilityIdRequested) result.runTrackingSkipped = [skipReason];
-  return result;
-};
-var resolveRecordingClient = (client, opts) => {
-  const credentials = client.getCredentials();
-  const recordingClient = opts.account ? client.withAccount(opts.account) : client;
-  const canRecord = opts.account !== void 0 || credentials.kind === "account" || credentials.kind === "session";
-  return { recordingClient, canRecord };
-};
-var recordErrorFetchRun = async (client, opts, result, capabilityIdOverride) => {
-  const effectiveCapId = opts.capabilityId;
-  if (effectiveCapId === void 0) return;
-  const { recordingClient, canRecord } = resolveRecordingClient(client, opts);
-  if (!canRecord) return;
-  const fetchOriginForRecord = opts.capabilityId === void 0 ? "direct_url" : opts.fetchOrigin;
-  try {
-    const created = await recordingClient.runs.create({
-      capabilityId: effectiveCapId,
-      ...opts.searchId && { searchId: opts.searchId },
-      ...fetchOriginForRecord && { fetchOrigin: fetchOriginForRecord },
-      ...result.status !== null && { status: result.status },
-      latencyMs: result.latencyMs,
-      ...opts.requestSchema && { requestSchema: opts.requestSchema }
-    });
-    result.runId = created.runId;
-    delete result.runTrackingSkipped;
-  } catch {
-  }
-};
-var recordTimeoutRun = async (client, opts, err, startedAt, capabilityIdRequested, capabilityIdOverride) => {
-  const result = errorFetchResult(
-    startedAt,
-    err.message,
-    "timeout",
-    capabilityIdRequested,
-    "network_error"
-  );
-  await recordErrorFetchRun(client, opts, result);
-};
-var sniffJsonShapeBytes = (buf) => {
-  let i = 0;
-  if (buf.length >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) {
-    i = 3;
-  }
-  while (i < buf.length && (buf[i] === 32 || buf[i] === 9 || buf[i] === 10 || buf[i] === 13)) {
-    i++;
-  }
-  if (i >= buf.length) return false;
-  return buf[i] === 123 || buf[i] === 91;
-};
-var withDefaultContentType = (headers, body) => {
-  if (!headers && body === void 0) return void 0;
-  const next = headers ? { ...headers } : {};
-  if (body === void 0) return next;
-  const hasContentType = Object.keys(next).some(
-    (k3) => k3.toLowerCase() === "content-type"
-  );
-  if (!hasContentType) {
-    next["content-type"] = typeof body === "string" || sniffJsonShapeBytes(body) ? "application/json" : "application/octet-stream";
-  }
-  return next;
-};
-var clientFetch = async (client, url4, opts = {}) => {
-  const startedAt = Date.now();
-  const capabilityIdRequested = opts.capabilityId !== void 0;
-  const normalized = normalizeTransportEnvelopeRequest(url4, {
-    method: opts.method,
-    body: opts.body
-  });
-  const requestUrl = normalized.url;
-  const requestBody = normalized.body;
-  const method = normalized.method ?? (requestBody !== void 0 ? "POST" : "GET");
-  const { canRecord: canRecordForResolve } = resolveRecordingClient(
-    client,
-    opts
-  );
-  const resolvePromise = !capabilityIdRequested && canRecordForResolve ? client.capabilities.resolveByUrl(redactUrl2(requestUrl), method).catch(() => null) : Promise.resolve(null);
-  const probeHeaders = withDefaultContentType(opts.headers, requestBody);
-  const requestInit = {
-    method,
-    headers: probeHeaders,
-    body: requestBody,
-    signal: opts.signal
-  };
-  const configuredFetch = buildConfiguredFetch(client, {
-    timeoutMs: opts.timeoutMs
-  });
-  let response;
-  let payment = null;
-  const skipReasons = [];
-  const warnings = [];
-  try {
-    response = await configuredFetch(requestUrl, requestInit);
-  } catch (err) {
-    if (err instanceof ZeroTimeoutError) {
-      await recordTimeoutRun(
-        client,
-        opts,
-        err,
-        startedAt,
-        capabilityIdRequested
-      );
-      throw err;
-    }
-    if (err instanceof ZeroError) throw err;
-    const errMessage = err instanceof Error ? err.message : String(err);
-    const result2 = errorFetchResult(
-      startedAt,
-      errMessage,
-      "fetch_failed_before_response",
-      capabilityIdRequested,
-      "network_error"
-    );
-    await recordErrorFetchRun(client, opts, result2);
-    return result2;
-  }
-  if (response.status === 402) {
-    const requirement = await detectPaymentRequirement(response);
-    if (requirement?.protocol === "x402" || requirement?.protocol === "mpp") {
-      const payCall = requirement.protocol === "x402" ? client.payments.pay : client.payments.payMpp;
-      try {
-        const paid = await payCall({
-          url: requestUrl,
-          method,
-          // Fresh clone for the paid retry — same rationale as
-          // the probe-side clone above. Re-derives the default
-          // Content-Type so the paid leg matches the probe.
-          headers: withDefaultContentType(opts.headers, requestBody),
-          body: requestBody,
-          maxPay: opts.maxPay,
-          account: opts.account,
-          signal: opts.signal,
-          timeoutMs: opts.timeoutMs,
-          ...opts.displayCostAmount && {
-            displayCostAmount: opts.displayCostAmount
-          }
-        });
-        response = paid.response;
-        payment = paid.payment;
-        if (paid.warnings) warnings.push(...paid.warnings);
-      } catch (err) {
-        if (err instanceof ZeroSessionCloseFailedError) {
-          response = err.response;
-          payment = {
-            protocol: "mpp",
-            chain: tempoChainLabelFromId(err.session.chainId),
-            txHash: null,
-            amount: err.capturedAmount,
-            asset: "USDC",
-            session: err.session
-          };
-          warnings.push(FETCH_WARNINGS.mppSessionCloseFailed);
-        } else if (err instanceof ZeroInsufficientFundsError) {
-          return errorFetchResult(
-            startedAt,
-            err.message,
-            FETCH_SKIP_REASONS.insufficientFunds,
-            capabilityIdRequested,
-            "insufficient_funds",
-            null
-          );
-        } else if (err instanceof ZeroPaymentError || err instanceof ZeroAuthError) {
-          const result2 = errorFetchResult(
-            startedAt,
-            err.message,
-            "payment_failed",
-            capabilityIdRequested,
-            "payment_failed",
-            402
-          );
-          await recordErrorFetchRun(client, opts, result2);
-          return result2;
-        } else if (err instanceof ZeroTimeoutError) {
-          await recordTimeoutRun(
-            client,
-            opts,
-            err,
-            startedAt,
-            capabilityIdRequested
-          );
-          throw err;
-        } else {
-          throw err;
-        }
+    {
+      method: "POST",
+      path: "/v1/runs",
+      body: input,
+      signal: opts.signal
+    },
+    createRunResponseSchema
+  );
+  list = (params = {}, opts = {}) => {
+    if (params.limit === 0) {
+      if (opts.signal?.aborted) {
+        return Promise.reject(
+          new ZeroApiError("Request aborted by caller", { status: 0 })
+        );
       }
-    } else if (requirement?.protocol === "unknown") {
-      const result2 = errorFetchResult(
-        startedAt,
-        "Capability returned 402 with an unrecognized payment protocol. Neither x402 nor MPP markers were detected in the response headers or body.",
-        "unrecognized_402_protocol",
-        capabilityIdRequested,
-        "payment_failed",
-        402
-      );
-      await recordErrorFetchRun(client, opts, result2);
-      return result2;
+      if (params.cursor === void 0) {
+        return Promise.reject(
+          new ZeroApiError(
+            "runs.list({ limit: 0 }) requires a cursor \u2014 without one the empty page is indistinguishable from end-of-stream",
+            { status: 0 }
+          )
+        );
+      }
+      return Promise.resolve({
+        runs: [],
+        nextCursor: params.cursor
+      });
     }
+    const query = {};
+    if (params.capabilityId !== void 0)
+      query.capabilityId = params.capabilityId;
+    if (params.unreviewed !== void 0) query.unreviewed = params.unreviewed;
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    return request2(
+      this.client,
+      {
+        method: "GET",
+        path: "/v1/runs",
+        query,
+        signal: opts.signal
+      },
+      listRunsResponseSchema
+    );
+  };
+  get = (runId, opts = {}) => request2(
+    this.client,
+    {
+      method: "GET",
+      path: `/v1/runs/${runId}`,
+      signal: opts.signal
+    },
+    runDetailSchema
+  );
+  review = (input, opts = {}) => request2(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/reviews",
+      body: input,
+      signal: opts.signal
+    },
+    createReviewResponseSchema
+  );
+  // Bulk review submission. The CLI's bulk JSONL parser stays CLI-side —
+  // SDK consumers pass already-parsed structured input.
+  createReviewsBatch = (reviews, opts = {}) => request2(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/reviews/batch",
+      body: { reviews },
+      signal: opts.signal
+    },
+    batchReviewResponseSchema
+  );
+};
+var USDC_BASE2 = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+var USDC_TEMPO2 = "0x20c000000000000000000000b9537d11c60e8b50";
+var TEMPO_CHAIN_ID2 = 4217;
+var baseChain = base;
+var tempoChain2 = {
+  id: TEMPO_CHAIN_ID2,
+  name: "Tempo",
+  nativeCurrency: { name: "USD", symbol: "USD", decimals: 18 },
+  rpcUrls: {
+    default: { http: ["https://rpc.tempo.xyz"] }
   }
-  const latencyMs = Date.now() - startedAt;
-  const maxResponseBytes = opts.maxResponseBytes ?? MAX_RESPONSE_BYTES;
-  let body;
-  let bodyRaw;
-  let bodyEncoding;
-  try {
-    const parsed = await parseResponseBody(response, maxResponseBytes);
-    body = parsed.body;
-    bodyRaw = parsed.bodyRaw;
-    bodyEncoding = parsed.bodyEncoding;
-    if (parsed.truncated) warnings.push(FETCH_WARNINGS.bodyTruncated);
-  } catch (err) {
-    if (err instanceof Error && err.name === "AbortError") {
-      throw new ZeroApiError("Request aborted by caller", {
-        status: 0,
-        cause: err
-      });
+};
+var ERC20_BALANCE_ABI2 = [
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var USDC_DECIMALS = 6;
+var fundingUrlResponseSchema = external_exports3.object({ url: external_exports3.string() });
+var userWalletListSchema = external_exports3.array(userWalletDtoSchema);
+var migrateAuthorizationResponseSchema = external_exports3.object({
+  transactionHash: external_exports3.string()
+});
+var errorMessage = (reason) => reason instanceof Error ? reason.message : String(reason);
+var Wallet = class {
+  constructor(client) {
+    this.client = client;
+  }
+  clients = {};
+  // The configured wallet address, or null if the client wasn't constructed
+  // with an account. Stable read — does not hit the network.
+  get address() {
+    const credentials = this.client.getCredentials();
+    if (credentials.kind !== "account") return null;
+    return credentials.account.address;
+  }
+  balance = async (opts = {}) => {
+    const target = opts.address ?? this.address;
+    if (!target) {
+      throw new ZeroWalletError(
+        "balance() requires either an `address` option or a client constructed with an account"
+      );
     }
-    const message2 = err instanceof Error ? err.message : String(err);
-    const skips = [];
-    const settledLocally = paymentHasAnchor(payment);
-    if (settledLocally && response.status === 402) {
-      warnings.push(FETCH_WARNINGS.paidButStill402NotRecorded);
-      skips.push(FETCH_WARNINGS.paidButStill402NotRecorded);
+    const chain2 = opts.chain ?? "total";
+    if (chain2 !== "total") {
+      const raw = await this.readChainBalance(chain2, target);
+      return { amount: formatUnits(raw, USDC_DECIMALS), asset: "USDC" };
     }
-    if (payment !== null && !settledLocally) {
-      warnings.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
-      skips.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
+    const chains = ["base", "tempo"];
+    const settled = await Promise.allSettled(
+      chains.map((c) => this.readChainBalance(c, target))
+    );
+    let sum = 0n;
+    const errors = [];
+    for (let i = 0; i < settled.length; i++) {
+      const result = settled[i];
+      const chainName = chains[i];
+      if (!result || !chainName) continue;
+      if (result.status === "fulfilled") {
+        sum += result.value;
+      } else {
+        errors.push({ chain: chainName, message: errorMessage(result.reason) });
+      }
     }
-    if (payment !== null && payment.amount === "unknown") {
-      warnings.push(FETCH_WARNINGS.paymentAmountUnknown);
+    if (errors.length === settled.length) {
+      throw new ZeroWalletError(
+        `balance() failed for every chain: ${errors.map((e2) => `${e2.chain} (${e2.message})`).join(", ")}`
+      );
     }
-    skips.push(FETCH_SKIP_REASONS.bodyReadFailed);
-    const result2 = {
-      runId: null,
-      ok: false,
-      status: response.status,
-      latencyMs: Date.now() - startedAt,
-      payment,
-      outcome: computeOutcome(response.status, payment, warnings),
-      body: null,
-      bodyRaw: null,
-      error: message2
+    const balance = {
+      amount: formatUnits(sum, USDC_DECIMALS),
+      asset: "USDC"
     };
-    if (capabilityIdRequested) result2.runTrackingSkipped = skips;
-    if (warnings.length > 0) result2.warnings = warnings;
-    return result2;
-  }
-  const settled = paymentHasAnchor(payment);
-  const paidButStill402 = settled && response.status === 402;
-  const settlementUnconfirmed = payment !== null && !settled;
-  if (paidButStill402) warnings.push(FETCH_WARNINGS.paidButStill402NotRecorded);
-  if (settlementUnconfirmed)
-    warnings.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
-  if (payment !== null && payment.amount === "unknown") {
-    warnings.push(FETCH_WARNINGS.paymentAmountUnknown);
-  }
-  let runId = null;
-  const closeFailed = warnings.includes(FETCH_WARNINGS.mppSessionCloseFailed);
-  const upstreamErrorForRecord = buildUpstreamError(
-    response.status,
-    bodyRaw,
-    bodyEncoding
+    if (errors.length > 0) balance.errors = errors;
+    return balance;
+  };
+  // All wallets linked to the authenticated session user. Session-only.
+  list = (opts = {}) => request2(
+    this.client,
+    {
+      method: "GET",
+      path: "/v1/users/me/wallets",
+      signal: opts.signal
+    },
+    userWalletListSchema
   );
-  if (capabilityIdRequested) {
-    if (paidButStill402)
-      skipReasons.push(FETCH_WARNINGS.paidButStill402NotRecorded);
-    else if (closeFailed)
-      skipReasons.push(FETCH_SKIP_REASONS.mppSessionCloseFailedNotRecorded);
-  }
-  const resolvedCap = await resolvePromise;
-  const effectiveCapabilityId = opts.capabilityId ?? resolvedCap?.capabilityId;
-  const capabilityResolution = !capabilityIdRequested && canRecordForResolve ? resolvedCap !== null ? {
-    resolved: true,
-    capabilityId: resolvedCap.capabilityId,
-    capabilitySlug: resolvedCap.capabilitySlug,
-    matchedVia: resolvedCap.matchedVia
-  } : { resolved: false } : void 0;
-  if (effectiveCapabilityId !== void 0 && !paidButStill402 && !closeFailed) {
-    const { recordingClient, canRecord } = resolveRecordingClient(client, opts);
-    if (!canRecord) {
-      skipReasons.push("no_credentials");
-    } else {
-      const knownAmount = payment !== null && payment.amount !== "unknown";
-      try {
-        let derived;
-        if (opts.deriveRunMetadata) {
-          try {
-            derived = opts.deriveRunMetadata({
-              status: response.status,
-              ok: response.ok,
-              bodyRaw,
-              ...bodyEncoding && { bodyEncoding }
-            });
-          } catch {
-          }
-        }
-        const result2 = await recordingClient.runs.create({
-          capabilityId: effectiveCapabilityId,
-          searchId: opts.searchId,
-          // Auto-resolved runs are always direct_url — they only fire when
-          // no capabilityId was supplied (the direct_url path by definition).
-          ...opts.capabilityId === void 0 ? { fetchOrigin: "direct_url" } : opts.fetchOrigin && { fetchOrigin: opts.fetchOrigin },
-          status: response.status,
-          latencyMs,
-          ...opts.requestSchema && { requestSchema: opts.requestSchema },
-          ...derived?.responseSchema && {
-            responseSchema: derived.responseSchema
-          },
-          ...upstreamErrorForRecord && {
-            errorSnippetHash: upstreamErrorForRecord.snippetHash,
-            errorSnippetLength: upstreamErrorForRecord.snippetLength
-          },
-          ...payment && {
-            ...knownAmount && {
-              costAmount: payment.amount,
-              costAsset: payment.asset
-            },
-            paymentProtocol: payment.protocol,
-            paymentChain: payment.chain,
-            paymentTxHash: payment.txHash ?? void 0,
-            paymentMode: payment.session ? "session" : "charge"
-          }
-        });
-        runId = result2.runId;
-      } catch (err) {
-        const errorMessage22 = err instanceof Error ? err.message : String(err);
-        const code = err instanceof ZeroError ? err.code : void 0;
-        const skipMsg = code ? `run_create_failed:${code}: ${errorMessage22}` : `run_create_failed: ${errorMessage22}`;
-        skipReasons.push(skipMsg);
-        client.logger?.({
-          level: "warn",
-          message: "Failed to record run for fetch",
-          meta: {
-            url: redactUrl2(url4),
-            capabilityId: effectiveCapabilityId,
-            error: errorMessage22,
-            errorCode: code
-          }
+  // Provision a managed (Privy-embedded) wallet for the session user.
+  // Idempotent server-side — repeat calls return the existing wallet.
+  provision = (opts = {}) => request2(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/users/me/wallets/provision",
+      signal: opts.signal
+    },
+    userWalletDtoSchema
+  );
+  // Relays a BYO-wallet-signed EIP-3009 ReceiveWithAuthorization, sweeping
+  // USDC from the BYO wallet to the user's Zero wallet on Base via the
+  // gas-paying relayer. The SDK does not author the authorization (chain
+  // nonce + EIP-712 domain coupling stays caller-side); it only forwards
+  // the signed payload. Session-only.
+  migrateAuthorization = (authorization, opts = {}) => request2(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/users/me/wallets/migrate",
+      body: { authorization },
+      signal: opts.signal
+    },
+    migrateAuthorizationResponseSchema
+  );
+  // Routes by identity: account mode signs EIP-191 against /v1/wallet/fund-url,
+  // session mode hits /v1/users/me/fund-url (Bearer-authed, wallet resolved
+  // server-side). Both honor `provider` (coinbase | stripe).
+  fundingUrl = async (opts = {}) => {
+    const credentials = this.client.getCredentials();
+    const path3 = credentials.kind === "account" ? "/v1/wallet/fund-url" : credentials.kind === "session" ? "/v1/users/me/fund-url" : null;
+    if (!path3) {
+      throw new ZeroWalletError(
+        "fundingUrl() requires a client constructed with an account or session credentials"
+      );
+    }
+    const query = {
+      provider: opts.provider ?? "coinbase"
+    };
+    if (opts.amount) query.amount = opts.amount;
+    const { url: url4 } = await request2(
+      this.client,
+      { method: "GET", path: path3, query, signal: opts.signal },
+      fundingUrlResponseSchema
+    );
+    return url4;
+  };
+  getPublicClient = (chain2) => {
+    if (chain2 === "base") {
+      if (!this.clients.base) {
+        this.clients.base = createPublicClient({
+          chain: baseChain,
+          transport: http()
         });
       }
+      return this.clients.base;
     }
-  }
-  const result = {
-    runId,
-    ok: response.ok,
-    status: response.status,
-    latencyMs,
-    payment,
-    outcome: computeOutcome(response.status, payment, warnings),
-    body,
-    bodyRaw
+    if (!this.clients.tempo) {
+      this.clients.tempo = createPublicClient({
+        // biome-ignore lint/suspicious/noExplicitAny: tempo is a custom chain object that viem's stricter Chain type rejects shape-wise but accepts at runtime
+        chain: tempoChain2,
+        transport: http()
+      });
+    }
+    return this.clients.tempo;
   };
-  if (bodyEncoding) result.bodyEncoding = bodyEncoding;
-  if (!response.ok) {
-    const candidate = bodyRaw !== null && bodyRaw.length > 0 && bodyEncoding !== "base64" ? bodyRaw.slice(0, 240) : null;
-    result.error = candidate !== null && !requestBodyEchoed(candidate, opts.body) ? candidate : `HTTP ${response.status}`;
-    if (upstreamErrorForRecord) result.upstreamError = upstreamErrorForRecord;
-  }
-  if (capabilityIdRequested && skipReasons.length > 0) {
-    result.runTrackingSkipped = skipReasons;
-  }
-  if (warnings.length > 0) result.warnings = warnings;
-  if (capabilityResolution !== void 0)
-    result.capabilityResolution = capabilityResolution;
-  return result;
+  /**
+   * @internal
+   *
+   * Per-chain USDC balance read. Exposed (rather than private) so unit
+   * tests can stub it without standing up a real viem public client —
+   * viem's `http()` transport doesn't go through `client.fetchImpl`, so
+   * the standard mock-fetch trick doesn't cover this path.
+   */
+  readChainBalance = async (chain2, address2) => {
+    const publicClient = this.getPublicClient(chain2);
+    const tokenAddress = chain2 === "base" ? USDC_BASE2 : USDC_TEMPO2;
+    const balance = await publicClient.readContract({
+      address: tokenAddress,
+      abi: ERC20_BALANCE_ABI2,
+      functionName: "balanceOf",
+      args: [address2]
+    });
+    return balance;
+  };
+};
+var DEFAULT_BASE_URL = "https://api.zero.xyz";
+var DEFAULT_TIMEOUT_MS = 18e4;
+var DEFAULT_MAX_RETRIES = 2;
+var noopRefresh = async () => {
 };
 var searchResultSchema = external_exports3.object({
   id: external_exports3.string(),
+  // Opaque attribution token (format: `z_{shortId}.{position}`). Optional
+  // so old API deploys that don't emit it still parse cleanly. Pass as
+  // capabilityId to client.fetch() for exact search attribution.
+  token: external_exports3.string().nullable().optional(),
   position: external_exports3.number(),
   slug: external_exports3.string(),
   name: external_exports3.string(),
@@ -146316,7 +146323,7 @@ Categories the classifier picks from:
 ).action(
   async (description, options) => {
     try {
-      const { analyticsService, client, stateService, walletAddress } = appContext.services;
+      const { analyticsService, client, walletAddress } = appContext.services;
       if (!walletAddress) {
         console.error(
           "Wallet auth required \u2014 run `zero auth login`, or `zero wallet set <key>` / set ZERO_PRIVATE_KEY."
@@ -146397,12 +146404,6 @@ Bulk bug-report complete: ${ok} ok, ${failed} failed`
       let { capability, run, search } = options;
       const useAutoContext = options.context !== false;
       if (useAutoContext) {
-        const lastSearch = stateService.loadLastSearch();
-        if (lastSearch) {
-          search = search ?? lastSearch.searchId;
-          const recent = lastSearch.capabilities[0];
-          capability = capability ?? recent?.id;
-        }
         if (!run) {
           try {
             const list2 = await client.runs.list({ limit: 1 });
@@ -146610,11 +146611,6 @@ var sniffJsonShape = (buf) => {
   if (i >= buf.length) return false;
   return buf[i] === 123 || buf[i] === 91;
 };
-var urlMatchesTemplate = (url4, template) => {
-  const escaped = template.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const withCaptures = escaped.replace(/\\\{[^/\\}]+\\\}/g, "[^/]+");
-  return new RegExp(`^${withCaptures}$`).test(url4);
-};
 var resolveRequestBody = (rawData, readStdin2) => {
   const fromFile = (spec) => {
     if (spec === "@-") return readFileSync(0);
@@ -146681,27 +146677,25 @@ var fetchCommand = (appContext) => new Command("fetch").description(
 ).action(
   async (url4, options) => {
     try {
-      const {
-        analyticsService,
-        client,
-        stateService,
-        walletAddress,
-        lowBalanceWarning
-      } = appContext.services;
+      const { analyticsService, client, walletAddress, lowBalanceWarning } = appContext.services;
+      const fromToken = options.capability ? isShortToken(options.capability) : false;
+      const effectiveCapRef = options.capability;
       let resolvedUrl;
       let resolvedMethodFromCapability;
+      let capFromNoUrl;
       if (!url4) {
         if (!options.capability) {
           console.error(
-            "Missing URL. Pass a URL argument or --capability <uid|slug> so the URL can be resolved from the capability."
+            "Missing URL. Pass a URL argument or --capability <uid|slug|token> so the URL can be resolved from the capability."
           );
           process.exitCode = 1;
           return;
         }
         try {
-          const cap = await client.capabilities.get(options.capability);
+          const cap = await client.capabilities.get(effectiveCapRef ?? "");
           resolvedUrl = cap.url;
           resolvedMethodFromCapability = cap.method;
+          capFromNoUrl = cap;
         } catch (err) {
           console.error(
             `Failed to resolve --capability ${options.capability}: ${err instanceof Error ? err.message : String(err)}`
@@ -146758,24 +146752,31 @@ var fetchCommand = (appContext) => new Command("fetch").description(
       }
       const log2 = (msg) => console.error(`  ${msg}`);
       const method = options.method ? options.method.toUpperCase() : resolvedMethodFromCapability ? resolvedMethodFromCapability.toUpperCase() : resolvedBody ? "POST" : "GET";
-      const explicitCapabilityCtx = options.capability ? stateService.findSearchContextByCapability(options.capability) : null;
-      const urlCtx = stateService.findSearchContextByUrl(resolvedUrl, {
-        matchTemplate: (template) => {
-          try {
-            return urlMatchesTemplate(resolvedUrl, template);
-          } catch {
-            return false;
-          }
-        }
-      });
-      const matchCtx = explicitCapabilityCtx ?? urlCtx;
-      const capabilityId = options.capability ?? matchCtx?.capabilityId ?? null;
-      let capabilityUid = matchCtx?.capabilityUid ?? null;
-      let capabilitySlug = matchCtx?.capabilitySlug ?? null;
-      const searchId = matchCtx?.searchId;
-      const resultRank = matchCtx?.resultRank;
-      const fetchOrigin = matchCtx ? "from_search" : options.capability ? "direct_slug" : "direct_url";
-      const matchedDisplayCostAmount = matchCtx?.displayCostAmount;
+      let capabilityId = null;
+      let capabilityUid = null;
+      let capabilitySlug = null;
+      let searchId;
+      let displayCostAmount;
+      let fetchOrigin;
+      if (fromToken) {
+        capabilityUid = capFromNoUrl?.uid ?? null;
+        capabilityId = options.capability ?? "";
+        capabilitySlug = capFromNoUrl?.slug ?? null;
+        displayCostAmount = capFromNoUrl?.displayCostAmount;
+        fetchOrigin = "from_search";
+      } else if (options.capability) {
+        capabilityUid = capFromNoUrl?.uid ?? null;
+        capabilitySlug = capFromNoUrl?.slug ?? null;
+        capabilityId = options.capability;
+        displayCostAmount = capFromNoUrl?.displayCostAmount;
+        fetchOrigin = "direct_slug";
+      } else {
+        const resolved = await client.capabilities.resolveByUrl(resolvedUrl, options.method ?? "GET").catch(() => null);
+        capabilityUid = resolved?.capabilityId ?? null;
+        capabilityId = capabilityUid;
+        fetchOrigin = "direct_url";
+      }
+      const resultRank = void 0;
       const cliSkipReasons = [];
       if (!walletAddress) {
         cliSkipReasons.push(
@@ -146811,16 +146812,17 @@ var fetchCommand = (appContext) => new Command("fetch").description(
           // Adaptive MPP channel prefund: when the seller sends no
           // suggestedDeposit and the caller didn't pass --max-pay,
           // the SDK scales the channel to 10× displayCostAmount so
-          // an expensive single call doesn't under-fund. Threaded
-          // from the search-cache entry.
-          ...matchedDisplayCostAmount && {
-            displayCostAmount: matchedDisplayCostAmount
-          },
+          // an expensive single call doesn't under-fund. Derived from
+          // the capability details when available (token or direct-slug
+          // paths that triggered a capabilities.get).
+          ...displayCostAmount && { displayCostAmount },
           // Only attach the capability when wallet auth is available;
           // recording without a wallet would skip server-side anyway,
           // and omitting here keeps result.runTrackingSkipped clean.
           ...capabilityId && walletAddress && { capabilityId },
-          ...searchId && { searchId },
+          // searchId intentionally omitted: server derives attribution
+          // via SearchAttributor (wallet + capId + 30-min window) so
+          // parallel fetches are race-free without shared client state.
           // Stamp how the agent arrived (from_search | direct_slug |
           // direct_url) onto the run's metadata so direct execution is
           // distinguishable from search-driven runs server-side. Only
@@ -146947,19 +146949,12 @@ var fetchCommand = (appContext) => new Command("fetch").description(
         } else {
           if (walletAddress && !runId) {
             cliSkipReasons.push(
-              "no capability resolved \u2014 pass --capability <uid|slug> or run `zero search` first so the URL can be matched"
+              "no capability resolved \u2014 pass --capability <uid|slug|token> or run `zero search` first so the URL can be matched"
             );
           }
-          const lastSearch = stateService.loadLastSearch();
-          const cached2 = lastSearch?.capabilities ?? [];
           analyticsService.capture("capability_resolution_missed", {
             url: redactUrl(resolvedUrl),
-            method,
-            hasLastSearch: lastSearch !== null,
-            lastSearchSize: cached2.length,
-            lastSearchHasTemplates: cached2.some(
-              (c) => Boolean(c.urlTemplate)
-            )
+            method
           });
         }
       }
@@ -147474,66 +147469,26 @@ var formatCapability = (capability) => {
   lines.push(...buildTryItExample(capability));
   return lines.join("\n");
 };
-var getCommand = (appContext) => new Command("get").description(
-  "Get details for a capability by position from last search, or by slug"
-).argument(
+var getCommand = (appContext) => new Command("get").description("Get details for a capability by token, slug, or uid").argument(
   "<identifier>",
-  "Position number from search results, or a capability slug"
+  "Attribution token (z_xxx.N from search results), capability slug, or uid"
 ).option("--formatted", "Output formatted capability details").option("--json", "Output raw JSON to stdout (default)").option(
   "--agent <name>",
   "Identify your agent host for this invocation. Overrides auto-detect for this call only."
 ).action(async (identifier, options) => {
   try {
-    const { analyticsService, client, stateService } = appContext.services;
-    const position = Number.parseInt(identifier, 10);
-    const isPosition = !Number.isNaN(position) && position >= 1;
-    let capabilityId;
-    let searchId;
-    if (isPosition) {
-      const lastSearch = stateService.loadLastSearch();
-      if (!lastSearch) {
-        console.error("No recent search found. Run `zero search` first.");
-        process.exitCode = 1;
-        return;
-      }
-      const entry = lastSearch.capabilities.find(
-        (c) => c.position === position
-      );
-      if (!entry) {
-        console.error(
-          `No capability at position ${position}. Positions: ${lastSearch.capabilities.map((c) => c.position).join(", ")}`
-        );
-        process.exitCode = 1;
-        return;
-      }
-      capabilityId = entry.id;
-      searchId = lastSearch.searchId;
-    } else {
-      capabilityId = identifier;
-      const ctx = stateService.findSearchContextByCapability(identifier);
-      if (ctx) searchId = ctx.searchId;
-    }
-    const capability = await client.capabilities.get(capabilityId, {
-      searchId
-    });
+    const { analyticsService, client } = appContext.services;
+    const capability = await client.capabilities.get(identifier);
     if (options.formatted && !options.json) {
       console.log(formatCapability(capability));
     } else {
       console.log(JSON.stringify(capability, null, 2));
     }
     analyticsService.capture("capability_viewed", {
-      // Existing field — raw user input (uid, slug, or position
-      // resolved to uid via the last-search cache). Preserved
-      // for back-compat with existing dashboards.
-      capabilityId,
-      // New canonical identifier fields read off the API response,
-      // so they are always populated regardless of how the user
-      // referenced the capability.
+      capabilityRef: identifier,
       capabilityUid: capability.uid,
       capabilitySlug: capability.slug,
-      fromLastSearch: isPosition,
-      ...isPosition ? { position } : {},
-      ...searchId ? { searchId } : {}
+      fromToken: isShortToken(identifier)
     });
   } catch (err) {
     console.error(err instanceof Error ? err.message : "Get failed");
@@ -148610,7 +148565,7 @@ var formatDetail = (r2) => {
   }
   return lines.join("\n");
 };
-var runsDetailCommand = (appContext) => new Command("detail").description("Show full metadata for a single run").argument("<runId>", "Run ID (run_\u2026)").option("--json", "Output raw JSON to stdout").action(async (runId, _opts, cmd) => {
+var runsDetailCommand = (appContext) => new Command("detail").description("Show full metadata for a single run (from server)").argument("<runId>", "Run ID (run_\u2026)").option("--json", "Output raw JSON to stdout").action(async (runId, _opts, cmd) => {
   const { json: json3 } = cmd.opts();
   try {
     const { client } = appContext.services;
@@ -148625,9 +148580,10 @@ var runsDetailCommand = (appContext) => new Command("detail").description("Show
     process.exitCode = 1;
   }
 });
-var runsCommand = (appContext) => new Command("runs").description("List your recent capability runs").addHelpText(
-  "after",
-  `
+var runsCommand = (appContext) => {
+  const cmd = new Command("runs").description("List your recent capability runs").addHelpText(
+    "after",
+    `
 View your recent capability runs \u2014 status, latency, cost, and payment info.
 A leading [\u2713] means the run already has a review; [ ] means it does not.
 
@@ -148636,52 +148592,55 @@ Examples:
   zero runs --unreviewed               # filter to runs without a review
   zero runs --capability translate-en  # filter to one capability (uid or slug)
   zero runs --json                     # full structured output for scripts
-  zero runs detail <runId>             # full metadata for a single run`
-).addCommand(runsDetailCommand(appContext)).option("--capability <id>", "Filter by capability uid or slug").option("--unreviewed", "Only show runs without a review").option(
-  "--limit <n>",
-  "Max rows (1-100, default 25)",
-  (v) => Number.parseInt(v, 10)
-).option("--json", "Output raw JSON to stdout").option(
-  "--agent <name>",
-  "Identify your agent host for this invocation. Overrides auto-detect for this call only."
-).action(
-  async (options) => {
-    try {
-      const { client } = appContext.services;
-      const result = await client.runs.list({
-        capabilityId: options.capability,
-        unreviewed: options.unreviewed,
-        limit: options.limit
-      });
-      if (options.json) {
-        console.log(JSON.stringify(result, null, 2));
-        return;
-      }
-      if (result.runs.length === 0) {
-        console.log("No runs found.");
-        return;
-      }
-      for (const r2 of result.runs) {
-        const when = r2.createdAt.toISOString().replace("T", " ").slice(0, 19);
-        const mark = r2.reviewed ? "\u2713" : " ";
-        const status = r2.status ?? "\u2014";
-        const latency = r2.latencyMs != null ? `${r2.latencyMs}ms` : "\u2014";
-        const cost = formatCost2(r2.cost);
-        const payment = formatPayment(r2.payment);
-        console.log(
-          `[${mark}] ${r2.uid}  ${r2.capabilitySlug}  status=${status}  ${latency}  ${cost}  ${payment}  ${when}`
-        );
-      }
-      if (result.nextCursor) {
-        console.log(`
+  zero runs detail <runId>             # full server-side metadata for a run`
+  ).option("--capability <id>", "Filter by capability uid or slug").option("--unreviewed", "Only show runs without a review").option(
+    "--limit <n>",
+    "Max rows (1-100, default 25)",
+    (v) => Number.parseInt(v, 10)
+  ).option("--json", "Output raw JSON to stdout").option(
+    "--agent <name>",
+    "Identify your agent host for this invocation. Overrides auto-detect for this call only."
+  ).action(
+    async (options) => {
+      try {
+        const { client } = appContext.services;
+        const result = await client.runs.list({
+          capabilityId: options.capability,
+          unreviewed: options.unreviewed,
+          limit: options.limit
+        });
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+        if (result.runs.length === 0) {
+          console.log("No runs found.");
+          return;
+        }
+        for (const r2 of result.runs) {
+          const when = r2.createdAt.toISOString().replace("T", " ").slice(0, 19);
+          const mark = r2.reviewed ? "\u2713" : " ";
+          const status = r2.status ?? "\u2014";
+          const latency = r2.latencyMs != null ? `${r2.latencyMs}ms` : "\u2014";
+          const cost = formatCost2(r2.cost);
+          const payment = formatPayment(r2.payment);
+          console.log(
+            `[${mark}] ${r2.uid}  ${r2.capabilitySlug}  status=${status}  ${latency}  ${cost}  ${payment}  ${when}`
+          );
+        }
+        if (result.nextCursor) {
+          console.log(`
 (more available \u2014 use --limit to see more)`);
+        }
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : "Failed");
+        process.exitCode = 1;
       }
-    } catch (err) {
-      console.error(err instanceof Error ? err.message : "Failed");
-      process.exitCode = 1;
     }
-  }
-);
+  );
+  cmd.addCommand(runsDetailCommand(appContext));
+  return cmd;
+};
 
 // src/commands/search-command.ts
 init_esm_shims();
@@ -148742,7 +148701,7 @@ var searchCommand = (appContext) => new Command("search").description("Search fo
 ).action(
   async (query, options) => {
     try {
-      const { analyticsService, client, stateService } = appContext.services;
+      const { analyticsService, client } = appContext.services;
       if (options.protocol && !["x402", "mpp"].includes(options.protocol)) {
         console.error(
           `Invalid protocol "${options.protocol}". Must be x402 or mpp.`
@@ -148811,17 +148770,6 @@ var searchCommand = (appContext) => new Command("search").description("Search fo
         );
         return;
       }
-      stateService.saveLastSearch({
-        searchId: result.searchId,
-        capabilities: result.capabilities.map((c) => ({
-          position: c.position,
-          id: c.id,
-          slug: c.slug,
-          url: c.url,
-          urlTemplate: c.urlTemplate ?? null,
-          displayCostAmount: c.cost.amount
-        }))
-      });
       console.log(formatSearchResults(result.capabilities));
       if (result.hasMore) {
         console.error(
@@ -148831,7 +148779,7 @@ var searchCommand = (appContext) => new Command("search").description("Search fo
       }
       if (result.capabilities.length > 0) {
         console.error(
-          "\n  Run `zero get {NUMBER}` to view a capability.\n"
+          "\n  Run `zero get <token>` (or `zero get <slug>`) to view a capability.\n"
         );
       }
     } catch (err) {
@@ -154114,105 +154062,6 @@ var AnalyticsService = class {
   }
 };
 
-// src/services/state-service.ts
-init_esm_shims();
-var RECENT_SEARCH_LIMIT = 10;
-var StateService = class {
-  constructor(zeroDir) {
-    this.zeroDir = zeroDir;
-    this.lastSearchPath = join(zeroDir, "last_search.json");
-    this.recentSearchesPath = join(zeroDir, "recent_searches.json");
-  }
-  lastSearchPath;
-  recentSearchesPath;
-  saveLastSearch = (data) => {
-    mkdirSync(this.zeroDir, { recursive: true });
-    writeFileSync(this.lastSearchPath, JSON.stringify(data, null, 2));
-    const recent = this.loadRecentSearches();
-    const filtered = recent.searches.filter(
-      (s) => s.searchId !== data.searchId
-    );
-    const next = [data, ...filtered].slice(0, RECENT_SEARCH_LIMIT);
-    writeFileSync(
-      this.recentSearchesPath,
-      JSON.stringify({ searches: next }, null, 2)
-    );
-  };
-  loadLastSearch = () => {
-    try {
-      if (!existsSync(this.lastSearchPath)) return null;
-      const raw = readFileSync(this.lastSearchPath, "utf8");
-      return JSON.parse(raw);
-    } catch {
-      return null;
-    }
-  };
-  loadRecentSearches = () => {
-    try {
-      if (!existsSync(this.recentSearchesPath)) {
-        const last = this.loadLastSearch();
-        return { searches: last ? [last] : [] };
-      }
-      const raw = readFileSync(this.recentSearchesPath, "utf8");
-      const parsed = JSON.parse(raw);
-      return { searches: parsed.searches ?? [] };
-    } catch {
-      return { searches: [] };
-    }
-  };
-  // Walk recent searches newest-first, returning the first one whose
-  // results contain `capabilityRef` (matches against uid OR slug).
-  // Preferred over "loadLastSearch" for attributing rank — handles the
-  // parallel-search case where the most recent search isn't the one being
-  // fetched.
-  findSearchContextByCapability = (capabilityRef) => {
-    const recent = this.loadRecentSearches();
-    for (const search of recent.searches) {
-      const entry = search.capabilities.find(
-        (c) => c.id === capabilityRef || c.slug === capabilityRef
-      );
-      if (entry) {
-        return {
-          searchId: search.searchId,
-          resultRank: entry.position,
-          capabilityId: entry.id,
-          capabilityUid: entry.id,
-          capabilitySlug: entry.slug ?? null,
-          url: entry.url,
-          displayCostAmount: entry.displayCostAmount
-        };
-      }
-    }
-    return null;
-  };
-  // URL-based attribution for `zero fetch <url>`. Matches by URL prefix
-  // (some capabilities accept query params or path tails the agent appends)
-  // across the recent ring, newest match wins. Falls back to a caller-
-  // supplied urlTemplate matcher (ADS-509 path-parameterized URLs).
-  findSearchContextByUrl = (url4, options) => {
-    const recent = this.loadRecentSearches();
-    for (const search of recent.searches) {
-      const prefixHit = search.capabilities.find((c) => url4.startsWith(c.url));
-      const templateHit = prefixHit ?? search.capabilities.find(
-        (c) => c.urlTemplate && options?.matchTemplate ? options.matchTemplate(c.urlTemplate) : false
-      );
-      const entry = templateHit;
-      if (entry) {
-        return {
-          searchId: search.searchId,
-          resultRank: entry.position,
-          capabilityId: entry.id,
-          capabilityUid: entry.id,
-          capabilitySlug: entry.slug ?? null,
-          url: entry.url,
-          displayCostAmount: entry.displayCostAmount
-        };
-      }
-    }
-    return null;
-  };
-};
-
 // src/services/wallet-migration-service.ts
 init_esm_shims();
 var USDC_BASE3 = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
@@ -154496,7 +154345,6 @@ var getServices = async (env) => {
   const walletMigrationService = new WalletMigrationService(
     byoAccount ?? legacyAccount
   );
-  const stateService = new StateService(zeroDir);
   const analyticsService = new AnalyticsService({
     walletAddress: account?.address ?? null,
     configPath,
@@ -154509,7 +154357,6 @@ var getServices = async (env) => {
     analyticsService,
     client,
     walletMigrationService,
-    stateService,
     lowBalanceWarning,
     // Canonical resolved wallet address across the CLI — covers BYO,
     // managed (Privy embedded) and legacy paths via the precedence above.