@zeroxyz/sdk 0.5.0 → 0.7.0

package/dist/{chunk-RY3VFSIE.js → chunk-26IHUYNK.js}

@@ -9,8 +9,8 @@ import { wrapFetchWithPayment } from '@x402/fetch';
 import { Receipt, Challenge } from 'mppx';
 import { Mppx, tempo } from 'mppx/client';
 import { base, baseSepolia } from 'viem/chains';
-import { z } from 'zod';
 import { createHash } from 'crypto';
+import { z } from 'zod';
 
 // src/auth/managed-account.ts
 var createManagedAccount = (client, address) => toAccount({
@@ -126,6 +126,78 @@ var ZeroConfigurationError = class extends ZeroError {
   }
 };
 
+// src/input-envelope.ts
+var asSchemaNode = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : null;
+var extractInputEnvelope = (bodySchema, method) => {
+  const root = asSchemaNode(bodySchema);
+  if (!root) return {};
+  const props = asSchemaNode(root.properties);
+  if (!props) return {};
+  const inputProps = asSchemaNode(asSchemaNode(props.input)?.properties);
+  if (inputProps) {
+    return {
+      queryParams: asSchemaNode(inputProps.queryParams) ?? void 0,
+      body: asSchemaNode(inputProps.body) ?? void 0
+    };
+  }
+  const upperMethod = method.toUpperCase();
+  const isGetLike = upperMethod === "GET" || upperMethod === "DELETE";
+  return isGetLike ? { queryParams: root } : { body: root };
+};
+var unwrapTransportEnvelope = (request2) => {
+  const input = asSchemaNode(asSchemaNode(request2)?.input);
+  if (!input || input.type !== "http") return request2;
+  const body = input.body;
+  const hasBody = body !== void 0 && body !== null && !(typeof body === "object" && Object.keys(body).length === 0);
+  if (hasBody) return body;
+  const qp = asSchemaNode(input.queryParams);
+  if (qp && Object.keys(qp).length > 0) return qp;
+  return null;
+};
+var GET_LIKE = /* @__PURE__ */ new Set(["GET", "HEAD", "DELETE"]);
+var appendQueryParams = (url, params) => {
+  const entries = Object.entries(params).filter(([, v]) => v != null);
+  if (entries.length === 0) return url;
+  try {
+    const u = new URL(url);
+    for (const [k, v] of entries) u.searchParams.set(k, String(v));
+    return u.toString();
+  } catch {
+    const qs = entries.map(
+      ([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`
+    ).join("&");
+    return url.includes("?") ? `${url}&${qs}` : `${url}?${qs}`;
+  }
+};
+var normalizeTransportEnvelopeRequest = (url, opts) => {
+  const { method, body } = opts;
+  if (typeof body !== "string") return { url, method, body };
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return { url, method, body };
+  }
+  const input = asSchemaNode(asSchemaNode(parsed)?.input);
+  if (!input || input.type !== "http") return { url, method, body };
+  const innerBody = input.body;
+  const hasInnerBody = innerBody !== void 0 && innerBody !== null && !(typeof innerBody === "object" && Object.keys(innerBody).length === 0);
+  const verb = (method ?? (typeof input.method === "string" ? input.method : void 0) ?? (hasInnerBody ? "POST" : "GET")).toUpperCase();
+  if (GET_LIKE.has(verb)) {
+    const qp = asSchemaNode(input.queryParams);
+    return {
+      url: qp ? appendQueryParams(url, qp) : url,
+      method: verb,
+      body: void 0
+    };
+  }
+  return {
+    url,
+    method: verb,
+    body: hasInnerBody ? JSON.stringify(innerBody) : void 0
+  };
+};
+
 // src/chains/eip712.ts
 var KNOWN_EIP712_DOMAINS = {
   // Base mainnet USDC. On-chain `name()` is "USD Coin" (NOT "USDC")
@@ -1141,1644 +1213,1688 @@ var Payments = class {
     };
   };
 };
-
-// package.json
-var package_default = {
-  version: "0.5.0"};
-
-// src/version.ts
-var SDK_VERSION = package_default.version;
-var userWalletDtoSchema = z.object({
-  walletAddress: z.string(),
-  source: z.enum(["self_custody", "privy_embedded"]),
-  isPrimary: z.boolean(),
-  linkedAt: z.union([z.string(), z.date()]).nullable().optional(),
-  delegationGranted: z.boolean(),
-  signerQuorumId: z.string().nullable(),
-  // Per-transaction USDC cap in base units (6 dp). null = unlimited, 0 = free-only.
-  maxTransactionUsdcBaseUnits: z.number().int().nullable()
-});
-var welcomeBonusSummarySchema = z.object({
-  status: z.string(),
-  amountUsd: z.number()
-});
-var internalUserDtoSchema = z.object({
-  id: z.string(),
-  email: z.string().nullable(),
-  createdAt: z.union([z.string(), z.date()]).optional(),
-  lastLoginAt: z.union([z.string(), z.date()]).nullable().optional(),
-  onboardingCompleted: z.boolean().optional(),
-  delegationGranted: z.boolean().optional(),
-  wallets: z.array(userWalletDtoSchema).optional(),
-  balance: z.object({ amount: z.string(), asset: z.string() }).nullable().optional(),
-  welcomeBonus: welcomeBonusSummarySchema.nullable().optional()
-});
-var publicUserDtoSchema = z.object({
-  user: z.object({
-    id: z.string(),
-    email: z.string().nullable()
-  }),
-  walletAddress: z.string().nullable(),
-  balance: z.object({ amount: z.string(), asset: z.string() }).nullable(),
-  welcomeBonus: welcomeBonusSummarySchema.nullable()
-});
-var signResponseSchema = z.object({
-  signature: z.string().regex(/^0x[0-9a-fA-F]+$/, "must be 0x-prefixed hex"),
-  walletAddress: z.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be 0x-prefixed 40-char hex address")
-});
-
-// src/schemas/device.ts
-var deviceStartResponseSchema = z.object({
-  deviceCode: z.string(),
-  userCode: z.string(),
-  verificationUri: z.string(),
-  pollInterval: z.number(),
-  expiresAt: z.number()
-});
-var devicePollResponseSchema = z.union([
-  // userCode + verificationUri are optional: older API deployments don't
-  // echo them on pending.
-  z.object({
-    error: z.literal("authorization_pending"),
-    userCode: z.string().optional(),
-    verificationUri: z.string().optional()
-  }),
-  z.object({ error: z.literal("expired_token") }),
-  z.object({
-    accessToken: z.string(),
-    refreshToken: z.string(),
-    expiresIn: z.number(),
-    user: internalUserDtoSchema
-  })
-]);
-var sessionExchangeResponseSchema = z.object({
-  token: z.string(),
-  expiresAt: z.number()
-});
-var refreshResponseSchema = z.object({
-  accessToken: z.string(),
-  refreshToken: z.string()
-});
-var tryRefreshSession = async (client, callerSignal) => {
-  const credentials = client.getCredentials();
-  if (credentials.kind !== "session") return false;
-  if (!credentials.refreshToken) return false;
-  const url = `${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(url, {
-      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 redactUrl = (url) => {
   try {
-    body = await response.json();
+    const u = new URL(url);
+    return `${u.origin}${u.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, nonce) => {
-  const bodyHash = createHash("sha256").update(body ?? "").digest("hex");
-  return `${method}:${pathWithQuery}:${bodyHash}:${timestamp}:${nonce}`;
 };
-var buildAccountAuthHeaders = async (account, method, pathWithQuery, body) => {
-  const timestamp = Math.floor(Date.now() / 1e3).toString();
-  const nonce = crypto.randomUUID();
-  const message = buildCanonicalMessage(
-    method,
-    pathWithQuery,
-    body,
-    timestamp,
-    nonce
+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 signature = await account.signMessage({ message });
-  return {
-    "x-zero-address": account.address,
-    "x-zero-timestamp": timestamp,
-    "x-zero-nonce": nonce,
-    "x-zero-signature": signature
-  };
-};
-
-// src/transport/http.ts
-var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 502, 503, 504]);
-var sleep = (ms, signal) => new Promise((resolve, reject) => {
-  if (signal?.aborted) {
-    reject(new DOMException("Aborted", "AbortError"));
-    return;
-  }
-  const timer = setTimeout(() => {
-    signal?.removeEventListener("abort", onAbort);
-    resolve();
-  }, ms);
-  const onAbort = () => {
-    clearTimeout(timer);
-    reject(new DOMException("Aborted", "AbortError"));
-  };
-  signal?.addEventListener("abort", onAbort, { once: true });
-});
-var buildPathWithQuery = (path, query) => {
-  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-  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));
+  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;
+    }
   }
-  const qs = params.toString();
-  return qs ? `${normalizedPath}?${qs}` : normalizedPath;
+  return false;
 };
-var joinUrl = (baseUrl, pathWithQuery) => {
-  const base3 = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-  return `${base3}${pathWithQuery}`;
+var cancelBody2 = (response) => {
+  try {
+    response.body?.cancel().catch(() => {
+    });
+  } catch {
+  }
 };
-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_VERSION;
-  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
+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(
+      (challenge) => challenge.trim().split(/\s+/)[0]?.toLowerCase() ?? ""
     );
-    Object.assign(headers, signed);
+    if (schemes.some((scheme) => MPP_SCHEME_TOKENS.has(scheme))) {
+      cancelBody2(response);
+      return { protocol: "mpp", raw: { "www-authenticate": wwwAuth } };
+    }
   }
-  return headers;
+  cancelBody2(response);
+  return { protocol: "unknown", raw: {} };
 };
-var parseErrorBody = async (response) => {
+var readClippedBytes = async (response, max) => {
+  if (response.body === null) return new Uint8Array(0);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
   try {
-    return await response.clone().json();
-  } catch {
+    while (total < max) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  } finally {
     try {
-      return await response.text();
+      await reader.cancel();
     } catch {
-      return void 0;
     }
   }
-};
-var errorMessageFromBody = (body, status) => {
-  if (body !== null && typeof body === "object" && "error" in body && typeof body.error === "string") {
-    return body.error;
+  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 `HTTP ${status}`;
+  return merged;
 };
-var request = async (client, opts, schema) => {
-  const pathWithQuery = buildPathWithQuery(opts.path, opts.query);
-  const url = 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(url, {
-    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;
+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 base64 = buf.toString("base64");
+    return {
+      body: base64,
+      bodyRaw: base64,
+      bodyEncoding: "base64",
+      truncated
+    };
+  }
+  const text = buf.toString("utf8");
+  if (contentType?.toLowerCase().includes("json")) {
     try {
-      response = await executeWithRefresh();
-    } catch (e) {
-      if (e instanceof ZeroError) throw e;
-      lastNetworkError = e;
-      if (attempt < client.maxRetries) {
-        try {
-          await sleep(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: e
-      });
+      return { body: JSON.parse(text), bodyRaw: text, truncated };
+    } catch {
     }
-    if (response.ok) {
-      let text;
-      try {
-        text = await response.text();
-      } catch (e) {
-        throw new ZeroApiError("Response body read failed", {
-          status: response.status,
-          cause: e
-        });
-      }
-      let json;
-      try {
-        json = JSON.parse(text);
-      } catch {
-      }
-      const parsed = schema.safeParse(json);
-      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;
+  }
+  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 record = parsed;
+  for (const field of UPSTREAM_ERROR_FIELDS) {
+    const value = record[field];
+    if (typeof value === "string" && value.length > 0) {
+      return clampUpstreamMessage(value);
     }
-    if (RETRYABLE_STATUS.has(response.status) && attempt < client.maxRetries) {
-      try {
-        await sleep(2 ** attempt * 200, opts.signal);
-      } catch (sleepErr) {
-        throw new ZeroApiError("Request aborted by caller", {
-          status: 0,
-          cause: sleepErr
-        });
+    if (value && typeof value === "object") {
+      const nested = value.message;
+      if (typeof nested === "string" && nested.length > 0) {
+        return clampUpstreamMessage(nested);
       }
-      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
-  });
+  return void 0;
 };
-
-// src/namespaces/auth-device.ts
-var AuthDevice = class {
-  constructor(client) {
-    this.client = client;
-  }
-  start = (opts = {}) => request(
-    this.client,
-    {
-      method: "POST",
-      path: "/v1/auth/device/start",
-      signal: opts.signal
-    },
-    deviceStartResponseSchema
-  );
-  poll = async (deviceCode, opts = {}) => {
-    const parsed = await request(
-      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 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 userWalletsSchema = z.array(userWalletDtoSchema);
-var normalizeMessage = (message) => {
-  if (typeof message === "string") return message;
-  if (typeof message.raw === "string") return message.raw;
-  return bytesToHex(message.raw);
+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 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 errorFetchResult = (startedAt, error, skipReason, capabilityIdRequested, outcome, status = null) => {
+  const result = {
+    runId: null,
+    ok: false,
+    status,
+    latencyMs: Date.now() - startedAt,
+    payment: null,
+    outcome,
+    body: null,
+    bodyRaw: null,
+    error
+  };
+  if (capabilityIdRequested) result.runTrackingSkipped = [skipReason];
+  return result;
 };
-var Auth = class {
-  constructor(client) {
-    this.client = client;
-    this.device = new AuthDevice(client);
+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 {
   }
-  device;
-  // The internal (web-app facing) user profile. Richer than profile(): full
-  // wallet list with per-wallet delegation/signer/limit metadata.
-  me = (opts = {}) => request(
-    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 = {}) => request(
-    this.client,
-    { method: "GET", path: "/v1/users/me/profile", signal: opts.signal },
-    publicUserDtoSchema
+};
+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 = {}) => request(
-    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(
+    (k) => k.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 = {}) => request(
-    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, url, opts = {}) => {
+  const startedAt = Date.now();
+  const capabilityIdRequested = opts.capabilityId !== void 0;
+  const normalized = normalizeTransportEnvelopeRequest(url, {
+    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 request(
-      this.client,
-      {
-        method: "POST",
-        path: "/v1/auth/logout",
-        body: { refreshToken },
-        signal: opts.signal
-      },
-      z.unknown()
-    );
+  const resolvePromise = !capabilityIdRequested && canRecordForResolve ? client.capabilities.resolveByUrl(redactUrl(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") {
+    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 parsed = await request(
-          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;
+        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, "signMessage");
+        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;
+        }
       }
+    } 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",
-      "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 request(
-          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");
-      }
+  }
+  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 === "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."
-      );
+    const message = 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);
     }
-    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 (payment !== null && !settledLocally) {
+      warnings.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
+      skips.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
     }
-    if (credentials.kind === "session") {
+    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: message
+    };
+    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 request(
-          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 errorMessage2 = err instanceof Error ? err.message : String(err);
+        const code = err instanceof ZeroError ? err.code : void 0;
+        const skipMsg = code ? `run_create_failed:${code}: ${errorMessage2}` : `run_create_failed: ${errorMessage2}`;
+        skipReasons.push(skipMsg);
+        client.logger?.({
+          level: "warn",
+          message: "Failed to record run for fetch",
+          meta: {
+            url: redactUrl(url),
+            capabilityId: effectiveCapabilityId,
+            error: errorMessage2,
+            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 = z.object({
-  bugReportId: z.string(),
+
+// package.json
+var package_default = {
+  version: "0.7.0"};
+
+// src/version.ts
+var SDK_VERSION = package_default.version;
+var userWalletDtoSchema = z.object({
+  walletAddress: z.string(),
+  source: z.enum(["self_custody", "privy_embedded"]),
+  isPrimary: z.boolean(),
+  linkedAt: z.union([z.string(), z.date()]).nullable().optional(),
+  delegationGranted: z.boolean(),
+  signerQuorumId: z.string().nullable(),
+  // Per-transaction USDC cap in base units (6 dp). null = unlimited, 0 = free-only.
+  maxTransactionUsdcBaseUnits: z.number().int().nullable()
+});
+var welcomeBonusSummarySchema = z.object({
   status: z.string(),
-  deduped: z.boolean(),
-  category: z.enum(BUG_REPORT_CATEGORIES).nullable(),
-  title: z.string().nullable(),
-  attached: z.object({
-    capabilityId: z.number().nullable(),
-    runId: z.number().nullable(),
-    searchId: z.number().nullable()
-  })
+  amountUsd: z.number()
 });
-
-// src/namespaces/bug-reports.ts
-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 = {}) => request(
-    this.client,
-    {
-      method: "POST",
-      path: "/v1/bug-reports",
-      body: input,
-      signal: opts.signal
-    },
-    createBugReportResponseSchema
-  );
-};
-var ratingSchema = z.object({
-  score: z.string(),
-  successRate: z.string(),
-  reviews: z.number(),
-  stars: z.string().nullable().optional(),
-  state: z.enum(["unrated", "rated"]).optional()
+var internalUserDtoSchema = z.object({
+  id: z.string(),
+  email: z.string().nullable(),
+  createdAt: z.union([z.string(), z.date()]).optional(),
+  lastLoginAt: z.union([z.string(), z.date()]).nullable().optional(),
+  onboardingCompleted: z.boolean().optional(),
+  delegationGranted: z.boolean().optional(),
+  wallets: z.array(userWalletDtoSchema).optional(),
+  balance: z.object({ amount: z.string(), asset: z.string() }).nullable().optional(),
+  welcomeBonus: welcomeBonusSummarySchema.nullable().optional()
 });
-
-// src/schemas/capabilities.ts
-var capabilityResponseSchema = z.object({
-  uid: z.string(),
-  slug: z.string(),
-  name: z.string(),
-  description: z.string(),
-  url: z.string(),
-  urlTemplate: z.string().nullable().optional(),
-  method: z.string(),
-  headers: z.record(z.string(), z.string()).nullable(),
-  bodySchema: z.record(z.string(), z.unknown()).nullable(),
-  responseSchema: z.record(z.string(), z.unknown()).nullable(),
-  example: z.object({ request: z.unknown(), response: z.unknown() }).nullable(),
-  tags: z.array(z.string()).nullable(),
-  exampleAgentPrompt: z.string().nullable().optional(),
-  displayCostAmount: z.string(),
-  displayCostAsset: z.string(),
-  reviewCount: z.number(),
-  rating: ratingSchema,
-  priceObserved: z.object({
-    minCents: z.string().nullable(),
-    medianCents: z.string().nullable(),
-    maxCents: z.string().nullable(),
-    // Deprecated alias for maxCents; kept for back-compat with older
-    // API versions that still emit it.
-    p95Cents: z.string().nullable(),
-    sampleCount: z.number(),
-    varies: z.boolean(),
-    failureChargeRate: z.number().nullable()
-  }).nullable().optional(),
-  paymentMethods: z.array(
-    z.object({
-      uid: z.string(),
-      protocol: z.string(),
-      methodType: z.string(),
-      chain: z.string().nullable(),
-      mode: z.string(),
-      costAmount: z.string(),
-      costPer: z.string(),
-      priority: z.number()
-    })
-  ).nullable(),
-  availabilityStatus: z.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: z.enum(["healthy", "stable", "degraded", "unhealthy", "unknown"]).optional(),
-  activationCount: z.number().optional(),
-  lastUsedAt: z.string().nullable().optional(),
-  lastSuccessfullyRanAt: z.string().nullable().optional()
+var publicUserDtoSchema = z.object({
+  user: z.object({
+    id: z.string(),
+    email: z.string().nullable()
+  }),
+  walletAddress: z.string().nullable(),
+  balance: z.object({ amount: z.string(), asset: z.string() }).nullable(),
+  welcomeBonus: welcomeBonusSummarySchema.nullable()
 });
-var resolveCapabilityResponseSchema = z.object({
-  capabilityId: z.string(),
-  capabilitySlug: z.string(),
-  matchedVia: z.enum(["exact", "template"])
+var signResponseSchema = z.object({
+  signature: z.string().regex(/^0x[0-9a-fA-F]+$/, "must be 0x-prefixed hex"),
+  walletAddress: z.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be 0x-prefixed 40-char hex address")
 });
 
-// src/namespaces/capabilities.ts
-var Capabilities = class {
-  constructor(client) {
-    this.client = client;
-  }
-  get = (id, opts = {}) => request(
-    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 (url, method, opts = {}) => {
-    try {
-      return await request(
-        this.client,
-        {
-          method: "POST",
-          path: "/v1/capabilities/resolve",
-          body: { url, method },
-          signal: opts.signal
-        },
-        resolveCapabilityResponseSchema
-      );
-    } catch (err) {
-      if (err instanceof ZeroApiError && err.status === 404) return null;
-      throw err;
-    }
-  };
-};
-var createRunResponseSchema = z.object({
-  runId: z.string()
+// src/schemas/device.ts
+var deviceStartResponseSchema = z.object({
+  deviceCode: z.string(),
+  userCode: z.string(),
+  verificationUri: z.string(),
+  pollInterval: z.number(),
+  expiresAt: z.number()
 });
-var runListItemSchema = z.object({
-  uid: z.string(),
-  capabilityUid: z.string(),
-  capabilitySlug: z.string(),
-  capabilityName: z.string(),
-  status: z.number().nullable(),
-  latencyMs: z.number().nullable(),
-  cost: z.object({ amount: z.string(), asset: z.string().nullable() }).nullable(),
-  payment: z.object({
-    protocol: z.string(),
-    chain: z.string().nullable(),
-    txHash: z.string().nullable(),
-    mode: z.string().nullable()
-  }).nullable(),
-  createdAt: z.coerce.date(),
-  reviewed: z.boolean()
-});
-var listRunsResponseSchema = z.object({
-  runs: z.array(runListItemSchema),
-  nextCursor: z.string().nullable()
-});
-var createReviewResponseSchema = z.object({
-  reviewId: z.string(),
-  recorded: z.boolean(),
-  updated: z.boolean().optional()
-});
-var batchReviewResponseSchema = z.object({
-  results: z.array(
-    z.union([
-      z.object({
-        runId: z.string(),
-        ok: z.literal(true),
-        reviewId: z.string(),
-        updated: z.boolean()
-      }),
-      z.object({
-        runId: z.string(),
-        ok: z.literal(false),
-        status: z.number(),
-        error: z.string()
-      })
-    ])
-  ),
-  summary: z.object({
-    total: z.number(),
-    ok: z.number(),
-    failed: z.number()
+var devicePollResponseSchema = z.union([
+  // userCode + verificationUri are optional: older API deployments don't
+  // echo them on pending.
+  z.object({
+    error: z.literal("authorization_pending"),
+    userCode: z.string().optional(),
+    verificationUri: z.string().optional()
+  }),
+  z.object({ error: z.literal("expired_token") }),
+  z.object({
+    accessToken: z.string(),
+    refreshToken: z.string(),
+    expiresIn: z.number(),
+    user: internalUserDtoSchema
   })
+]);
+var sessionExchangeResponseSchema = z.object({
+  token: z.string(),
+  expiresAt: z.number()
 });
-
-// src/namespaces/runs.ts
-var Runs = class {
-  constructor(client) {
-    this.client = client;
-  }
-  create = (input, opts = {}) => request(
-    this.client,
-    {
+var refreshResponseSchema = z.object({
+  accessToken: z.string(),
+  refreshToken: z.string()
+});
+var tryRefreshSession = async (client, callerSignal) => {
+  const credentials = client.getCredentials();
+  if (credentials.kind !== "session") return false;
+  if (!credentials.refreshToken) return false;
+  const url = `${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(url, {
       method: "POST",
-      path: "/v1/runs",
-      body: input,
-      signal: opts.signal
-    },
-    createRunResponseSchema
+      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 buildSessionAuthHeaders = (accessToken) => ({
+  authorization: `Bearer ${accessToken}`
+});
+var buildCanonicalMessage = (method, pathWithQuery, body, timestamp, nonce) => {
+  const bodyHash = createHash("sha256").update(body ?? "").digest("hex");
+  return `${method}:${pathWithQuery}:${bodyHash}:${timestamp}:${nonce}`;
+};
+var buildAccountAuthHeaders = async (account, method, pathWithQuery, body) => {
+  const timestamp = Math.floor(Date.now() / 1e3).toString();
+  const nonce = crypto.randomUUID();
+  const message = buildCanonicalMessage(
+    method,
+    pathWithQuery,
+    body,
+    timestamp,
+    nonce
   );
-  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 request(
-      this.client,
-      {
-        method: "GET",
-        path: "/v1/runs",
-        query,
-        signal: opts.signal
-      },
-      listRunsResponseSchema
-    );
+  const signature = await account.signMessage({ message });
+  return {
+    "x-zero-address": account.address,
+    "x-zero-timestamp": timestamp,
+    "x-zero-nonce": nonce,
+    "x-zero-signature": signature
   };
-  review = (input, opts = {}) => request(
-    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 = {}) => request(
-    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;
 
-// src/namespaces/wallet.ts
-var fundingUrlResponseSchema = z.object({ url: z.string() });
-var userWalletListSchema = z.array(userWalletDtoSchema);
-var migrateAuthorizationResponseSchema = z.object({
-  transactionHash: z.string()
-});
-var errorMessage = (reason) => reason instanceof Error ? reason.message : String(reason);
-var Wallet = class {
-  constructor(client) {
-    this.client = client;
+// src/transport/http.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 502, 503, 504]);
+var sleep = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) {
+    reject(new DOMException("Aborted", "AbortError"));
+    return;
   }
-  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;
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(new DOMException("Aborted", "AbortError"));
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+var buildPathWithQuery = (path, query) => {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  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));
   }
-  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 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_VERSION;
+  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;
     }
-    const chain = opts.chain ?? "total";
-    if (chain !== "total") {
-      const raw = await this.readChainBalance(chain, target);
-      return { amount: formatUnits(raw, USDC_DECIMALS), asset: "USDC" };
+  }
+};
+var errorMessageFromBody = (body, status) => {
+  if (body !== null && typeof body === "object" && "error" in body && typeof body.error === "string") {
+    return body.error;
+  }
+  return `HTTP ${status}`;
+};
+var request = async (client, opts, schema) => {
+  const pathWithQuery = buildPathWithQuery(opts.path, opts.query);
+  const url = 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(url, {
+    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 (e) {
+      if (e instanceof ZeroError) throw e;
+      lastNetworkError = e;
+      if (attempt < client.maxRetries) {
+        try {
+          await sleep(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: e
+      });
     }
-    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 (response.ok) {
+      let text;
+      try {
+        text = await response.text();
+      } catch (e) {
+        throw new ZeroApiError("Response body read failed", {
+          status: response.status,
+          cause: e
+        });
+      }
+      let json;
+      try {
+        json = JSON.parse(text);
+      } catch {
+      }
+      const parsed = schema.safeParse(json);
+      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 (errors.length === settled.length) {
-      throw new ZeroWalletError(
-        `balance() failed for every chain: ${errors.map((e) => `${e.chain} (${e.message})`).join(", ")}`
-      );
+    if (RETRYABLE_STATUS.has(response.status) && attempt < client.maxRetries) {
+      try {
+        await sleep(2 ** attempt * 200, opts.signal);
+      } catch (sleepErr) {
+        throw new ZeroApiError("Request aborted by caller", {
+          status: 0,
+          cause: sleepErr
+        });
+      }
+      continue;
     }
-    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 = {}) => request(
-    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 = {}) => request(
-    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 = {}) => request(
+    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
+  });
+};
+
+// src/namespaces/auth-device.ts
+var AuthDevice = class {
+  constructor(client) {
+    this.client = client;
+  }
+  start = (opts = {}) => request(
     this.client,
     {
       method: "POST",
-      path: "/v1/users/me/wallets/migrate",
-      body: { authorization },
+      path: "/v1/auth/device/start",
       signal: opts.signal
     },
-    migrateAuthorizationResponseSchema
+    deviceStartResponseSchema
   );
-  // 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 path = credentials.kind === "account" ? "/v1/wallet/fund-url" : credentials.kind === "session" ? "/v1/users/me/fund-url" : null;
-    if (!path) {
-      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 } = await request(
+  poll = async (deviceCode, opts = {}) => {
+    const parsed = await request(
       this.client,
-      { method: "GET", path, query, signal: opts.signal },
-      fundingUrlResponseSchema
+      {
+        method: "POST",
+        path: "/v1/auth/device/poll",
+        body: { deviceCode },
+        signal: opts.signal
+      },
+      devicePollResponseSchema
     );
-    return url;
-  };
-  getPublicClient = (chain) => {
-    if (chain === "base") {
-      if (!this.clients.base) {
-        this.clients.base = createPublicClient({
-          chain: baseChain,
-          transport: http()
-        });
-      }
-      return this.clients.base;
+    if ("error" in parsed) {
+      return parsed.error === "authorization_pending" ? {
+        status: "pending",
+        userCode: parsed.userCode,
+        verificationUri: parsed.verificationUri
+      } : { status: "expired" };
     }
-    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 (chain, address) => {
-    const publicClient = this.getPublicClient(chain);
-    const tokenAddress = chain === "base" ? USDC_BASE2 : USDC_TEMPO2;
-    const balance = await publicClient.readContract({
-      address: tokenAddress,
-      abi: ERC20_BALANCE_ABI2,
-      functionName: "balanceOf",
-      args: [address]
-    });
-    return balance;
+    return {
+      status: "ok",
+      accessToken: parsed.accessToken,
+      refreshToken: parsed.refreshToken,
+      expiresIn: parsed.expiresIn,
+      user: parsed.user
+    };
   };
 };
-
-// src/options.ts
-var DEFAULT_BASE_URL = "https://api.zero.xyz";
-var DEFAULT_TIMEOUT_MS = 18e4;
-var DEFAULT_MAX_RETRIES = 2;
-
-// src/auth/credentials.ts
-var noopRefresh = async () => {
+var userWalletsSchema = z.array(userWalletDtoSchema);
+var normalizeMessage = (message) => {
+  if (typeof message === "string") return message;
+  if (typeof message.raw === "string") return message.raw;
+  return bytesToHex(message.raw);
 };
-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;
+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 }
+    );
   }
-  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));
+  throw err;
 };
-var redactUrl = (url) => {
-  try {
-    const u = new URL(url);
-    return `${u.origin}${u.pathname}`;
-  } catch {
-    return "<invalid url>";
+var Auth = class {
+  constructor(client) {
+    this.client = client;
+    this.device = new AuthDevice(client);
   }
-};
-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
+  device;
+  // The internal (web-app facing) user profile. Richer than profile(): full
+  // wallet list with per-wallet delegation/signer/limit metadata.
+  me = (opts = {}) => request(
+    this.client,
+    { method: "GET", path: "/v1/users/me", signal: opts.signal },
+    internalUserDtoSchema
   );
-  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;
+  // 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 = {}) => request(
+    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 = {}) => request(
+    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 = {}) => request(
+    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 request(
+      this.client,
+      {
+        method: "POST",
+        path: "/v1/auth/logout",
+        body: { refreshToken },
+        signal: opts.signal
+      },
+      z.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
+      );
     }
-  }
-  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")
+    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."
       );
-      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 };
-        }
+  };
+  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 request(
+          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");
       }
-    } catch {
     }
-  }
-  const wwwAuth = response.headers.get("www-authenticate");
-  if (wwwAuth) {
-    const schemes = splitWwwAuthenticateChallenges(wwwAuth).map(
-      (challenge) => challenge.trim().split(/\s+/)[0]?.toLowerCase() ?? ""
+    throw new ZeroAuthError(
+      "auth_no_credentials",
+      "signMessage() requires the client to be constructed with `account` or `session`."
     );
-    if (schemes.some((scheme) => MPP_SCHEME_TOKENS.has(scheme))) {
-      cancelBody2(response);
-      return { protocol: "mpp", raw: { "www-authenticate": wwwAuth } };
+  };
+  // 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 request(
+          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");
+      }
     }
-  }
-  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;
+    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."
+      );
     }
-  } finally {
-    try {
-      await reader.cancel();
-    } catch {
+    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 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 base64 = buf.toString("base64");
-    return {
-      body: base64,
-      bodyRaw: base64,
-      bodyEncoding: "base64",
-      truncated
-    };
-  }
-  const text = buf.toString("utf8");
-  if (contentType?.toLowerCase().includes("json")) {
-    try {
-      return { body: JSON.parse(text), bodyRaw: text, truncated };
-    } catch {
+    if (credentials.kind === "session") {
+      try {
+        const parsed = await request(
+          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");
+      }
     }
-  }
-  return { body: text, bodyRaw: text, truncated };
+    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 UPSTREAM_ERROR_FIELDS = [
-  "error",
-  "message",
-  "detail",
-  "reason",
-  "error_description"
+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 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 createBugReportResponseSchema = z.object({
+  bugReportId: z.string(),
+  status: z.string(),
+  deduped: z.boolean(),
+  category: z.enum(BUG_REPORT_CATEGORIES).nullable(),
+  title: z.string().nullable(),
+  attached: z.object({
+    capabilityId: z.number().nullable(),
+    runId: z.number().nullable(),
+    searchId: z.number().nullable()
+  })
+});
+
+// src/namespaces/bug-reports.ts
+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 = {}) => request(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/bug-reports",
+      body: input,
+      signal: opts.signal
+    },
+    createBugReportResponseSchema
+  );
 };
-var extractUpstreamErrorMessage = (body) => {
-  const parsed = tryParseJson(body);
-  if (parsed === null || typeof parsed !== "object") {
-    return clampUpstreamMessage(body);
+var ratingSchema = z.object({
+  score: z.string(),
+  successRate: z.string(),
+  reviews: z.number(),
+  stars: z.string().nullable().optional(),
+  state: z.enum(["unrated", "rated"]).optional()
+});
+
+// src/schemas/capabilities.ts
+var capabilityResponseSchema = z.object({
+  uid: z.string(),
+  slug: z.string(),
+  name: z.string(),
+  description: z.string(),
+  url: z.string(),
+  urlTemplate: z.string().nullable().optional(),
+  method: z.string(),
+  headers: z.record(z.string(), z.string()).nullable(),
+  bodySchema: z.record(z.string(), z.unknown()).nullable(),
+  responseSchema: z.record(z.string(), z.unknown()).nullable(),
+  example: z.object({ request: z.unknown(), response: z.unknown() }).nullable(),
+  tags: z.array(z.string()).nullable(),
+  exampleAgentPrompt: z.string().nullable().optional(),
+  displayCostAmount: z.string(),
+  displayCostAsset: z.string(),
+  reviewCount: z.number(),
+  rating: ratingSchema,
+  priceObserved: z.object({
+    minCents: z.string().nullable(),
+    medianCents: z.string().nullable(),
+    maxCents: z.string().nullable(),
+    // Deprecated alias for maxCents; kept for back-compat with older
+    // API versions that still emit it.
+    p95Cents: z.string().nullable(),
+    sampleCount: z.number(),
+    varies: z.boolean(),
+    failureChargeRate: z.number().nullable()
+  }).nullable().optional(),
+  paymentMethods: z.array(
+    z.object({
+      uid: z.string(),
+      protocol: z.string(),
+      methodType: z.string(),
+      chain: z.string().nullable(),
+      mode: z.string(),
+      costAmount: z.string(),
+      costPer: z.string(),
+      priority: z.number()
+    })
+  ).nullable(),
+  availabilityStatus: z.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: z.enum(["healthy", "stable", "degraded", "unhealthy", "unknown"]).optional(),
+  activationCount: z.number().optional(),
+  lastUsedAt: z.string().nullable().optional(),
+  lastSuccessfullyRanAt: z.string().nullable().optional()
+});
+var resolveCapabilityResponseSchema = z.object({
+  capabilityId: z.string(),
+  capabilitySlug: z.string(),
+  matchedVia: z.enum(["exact", "template"])
+});
+
+// src/namespaces/capabilities.ts
+var Capabilities = class {
+  constructor(client) {
+    this.client = client;
   }
-  const record = parsed;
-  for (const field of UPSTREAM_ERROR_FIELDS) {
-    const value = record[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);
-      }
+  get = (id, opts = {}) => request(
+    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 (url, method, opts = {}) => {
+    try {
+      return await request(
+        this.client,
+        {
+          method: "POST",
+          path: "/v1/capabilities/resolve",
+          body: { url, method },
+          signal: opts.signal
+        },
+        resolveCapabilityResponseSchema
+      );
+    } catch (err) {
+      if (err instanceof ZeroApiError && err.status === 404) return null;
+      throw err;
     }
-  }
-  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, error, skipReason, capabilityIdRequested, outcome, status = null) => {
-  const result = {
-    runId: null,
-    ok: false,
-    status,
-    latencyMs: Date.now() - startedAt,
-    payment: null,
-    outcome,
-    body: null,
-    bodyRaw: null,
-    error
-  };
-  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 createRunResponseSchema = z.object({
+  runId: z.string()
+});
+var runListItemSchema = z.object({
+  uid: z.string(),
+  capabilityUid: z.string(),
+  capabilitySlug: z.string(),
+  capabilityName: z.string(),
+  status: z.number().nullable(),
+  latencyMs: z.number().nullable(),
+  cost: z.object({ amount: z.string(), asset: z.string().nullable() }).nullable(),
+  payment: z.object({
+    protocol: z.string(),
+    chain: z.string().nullable(),
+    txHash: z.string().nullable(),
+    mode: z.string().nullable()
+  }).nullable(),
+  createdAt: z.coerce.date(),
+  reviewed: z.boolean()
+});
+var listRunsResponseSchema = z.object({
+  runs: z.array(runListItemSchema),
+  nextCursor: z.string().nullable()
+});
+var runDetailSchema = z.object({
+  runId: z.string(),
+  status: z.number().nullable(),
+  latencyMs: z.number().nullable(),
+  errorClass: z.string().nullable(),
+  createdAt: z.coerce.date(),
+  cost: z.object({ amount: z.string(), asset: z.string().nullable() }).nullable(),
+  payment: z.object({
+    protocol: z.string(),
+    chain: z.string().nullable(),
+    txHash: z.string().nullable(),
+    mode: z.string().nullable()
+  }).nullable(),
+  capability: z.object({
+    uid: z.string(),
+    slug: z.string(),
+    name: z.string(),
+    url: z.string(),
+    method: z.string(),
+    whatItDoes: z.string().nullable(),
+    tags: z.array(z.string())
+  }),
+  reviewed: z.boolean()
+});
+var createReviewResponseSchema = z.object({
+  reviewId: z.string(),
+  recorded: z.boolean(),
+  updated: z.boolean().optional()
+});
+var batchReviewResponseSchema = z.object({
+  results: z.array(
+    z.union([
+      z.object({
+        runId: z.string(),
+        ok: z.literal(true),
+        reviewId: z.string(),
+        updated: z.boolean()
+      }),
+      z.object({
+        runId: z.string(),
+        ok: z.literal(false),
+        status: z.number(),
+        error: z.string()
+      })
+    ])
+  ),
+  summary: z.object({
+    total: z.number(),
+    ok: z.number(),
+    failed: z.number()
+  })
+});
+
+// src/namespaces/runs.ts
+var Runs = class {
+  constructor(client) {
+    this.client = client;
   }
-};
-var recordTimeoutRun = async (client, opts, err, startedAt, capabilityIdRequested, capabilityIdOverride) => {
-  const result = errorFetchResult(
-    startedAt,
-    err.message,
-    "timeout",
-    capabilityIdRequested,
-    "network_error"
+  create = (input, opts = {}) => request(
+    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 request(
+      this.client,
+      {
+        method: "GET",
+        path: "/v1/runs",
+        query,
+        signal: opts.signal
+      },
+      listRunsResponseSchema
+    );
+  };
+  get = (runId, opts = {}) => request(
+    this.client,
+    {
+      method: "GET",
+      path: `/v1/runs/${runId}`,
+      signal: opts.signal
+    },
+    runDetailSchema
+  );
+  review = (input, opts = {}) => request(
+    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 = {}) => request(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/reviews/batch",
+      body: { reviews },
+      signal: opts.signal
+    },
+    batchReviewResponseSchema
   );
-  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++;
+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"] }
   }
-  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(
-    (k) => k.toLowerCase() === "content-type"
-  );
-  if (!hasContentType) {
-    next["content-type"] = typeof body === "string" || sniffJsonShapeBytes(body) ? "application/json" : "application/octet-stream";
+var ERC20_BALANCE_ABI2 = [
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
   }
-  return next;
-};
-var clientFetch = async (client, url, opts = {}) => {
-  const startedAt = Date.now();
-  const capabilityIdRequested = opts.capabilityId !== void 0;
-  const method = opts.method ?? (opts.body !== void 0 ? "POST" : "GET");
-  const { canRecord: canRecordForResolve } = resolveRecordingClient(
-    client,
-    opts
-  );
-  const resolvePromise = !capabilityIdRequested && canRecordForResolve ? client.capabilities.resolveByUrl(redactUrl(url), method).catch(() => null) : Promise.resolve(null);
-  const probeHeaders = withDefaultContentType(opts.headers, opts.body);
-  const requestInit = {
-    method,
-    headers: probeHeaders,
-    body: opts.body,
-    signal: opts.signal
-  };
-  const configuredFetch = buildConfiguredFetch(client, {
-    timeoutMs: opts.timeoutMs
-  });
-  let response;
-  let payment = null;
-  const skipReasons = [];
-  const warnings = [];
-  try {
-    response = await configuredFetch(url, 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;
+];
+var USDC_DECIMALS = 6;
+
+// src/namespaces/wallet.ts
+var fundingUrlResponseSchema = z.object({ url: z.string() });
+var userWalletListSchema = z.array(userWalletDtoSchema);
+var migrateAuthorizationResponseSchema = z.object({
+  transactionHash: z.string()
+});
+var errorMessage = (reason) => reason instanceof Error ? reason.message : String(reason);
+var Wallet = class {
+  constructor(client) {
+    this.client = client;
   }
-  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,
-          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, opts.body),
-          body: opts.body,
-          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;
-        }
-      }
-    } 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;
-    }
+  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;
   }
-  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
-      });
+  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 message = 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 chain = opts.chain ?? "total";
+    if (chain !== "total") {
+      const raw = await this.readChainBalance(chain, 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((e) => `${e.chain} (${e.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: message
+    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 = {}) => request(
+    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 errorMessage2 = err instanceof Error ? err.message : String(err);
-        const code = err instanceof ZeroError ? err.code : void 0;
-        const skipMsg = code ? `run_create_failed:${code}: ${errorMessage2}` : `run_create_failed: ${errorMessage2}`;
-        skipReasons.push(skipMsg);
-        client.logger?.({
-          level: "warn",
-          message: "Failed to record run for fetch",
-          meta: {
-            url: redactUrl(url),
-            capabilityId: effectiveCapabilityId,
-            error: errorMessage2,
-            errorCode: code
-          }
+  // Provision a managed (Privy-embedded) wallet for the session user.
+  // Idempotent server-side — repeat calls return the existing wallet.
+  provision = (opts = {}) => request(
+    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 = {}) => request(
+    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 path = credentials.kind === "account" ? "/v1/wallet/fund-url" : credentials.kind === "session" ? "/v1/users/me/fund-url" : null;
+    if (!path) {
+      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 } = await request(
+      this.client,
+      { method: "GET", path, query, signal: opts.signal },
+      fundingUrlResponseSchema
+    );
+    return url;
+  };
+  getPublicClient = (chain) => {
+    if (chain === "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 (chain, address) => {
+    const publicClient = this.getPublicClient(chain);
+    const tokenAddress = chain === "base" ? USDC_BASE2 : USDC_TEMPO2;
+    const balance = await publicClient.readContract({
+      address: tokenAddress,
+      abi: ERC20_BALANCE_ABI2,
+      functionName: "balanceOf",
+      args: [address]
+    });
+    return balance;
+  };
+};
+
+// src/options.ts
+var DEFAULT_BASE_URL = "https://api.zero.xyz";
+var DEFAULT_TIMEOUT_MS = 18e4;
+var DEFAULT_MAX_RETRIES = 2;
+
+// src/auth/credentials.ts
+var noopRefresh = async () => {
 };
 var searchResultSchema = z.object({
   id: z.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: z.string().nullable().optional(),
   position: z.number(),
   slug: z.string(),
   name: z.string(),
@@ -2797,6 +2913,9 @@ var searchResultSchema = z.object({
   cost: z.object({ amount: z.string(), asset: z.string() }),
   reviewCount: z.number().optional(),
   rating: ratingSchema,
+  // All-time activation count (non-deleted runs), mirroring capabilities.ts.
+  // Optional so a response from an older API deploy still parses (ZERO-385).
+  activationCount: z.number().optional(),
   availabilityStatus: z.enum(["healthy", "unknown", "down"]).nullable().optional(),
   /**
    * @deprecated The API no longer emits `displayStatus`; it has been replaced
@@ -3188,6 +3307,6 @@ var ZeroClient = class _ZeroClient {
   };
 };
 
-export { Auth, AuthDevice, BUG_REPORT_CATEGORIES, BugReports, Capabilities, DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT_MS, FETCH_SKIP_REASONS, FETCH_WARNINGS, Payments, Runs, SDK_VERSION, TEMPO_CHAIN_ID, TEMPO_TESTNET_CHAIN_ID, Wallet, ZeroApiError, ZeroAuthError, ZeroClient, ZeroConfigurationError, ZeroError, ZeroPaymentError, ZeroSessionCloseFailedError, ZeroTimeoutError, ZeroValidationError, ZeroWalletError, coerceTempoChainId, createManagedAccount, paymentHasAnchor, tempoChainLabelFromId };
-//# sourceMappingURL=chunk-RY3VFSIE.js.map
-//# sourceMappingURL=chunk-RY3VFSIE.js.map
+export { Auth, AuthDevice, BUG_REPORT_CATEGORIES, BugReports, Capabilities, DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT_MS, FETCH_SKIP_REASONS, FETCH_WARNINGS, Payments, Runs, SDK_VERSION, TEMPO_CHAIN_ID, TEMPO_TESTNET_CHAIN_ID, Wallet, ZeroApiError, ZeroAuthError, ZeroClient, ZeroConfigurationError, ZeroError, ZeroPaymentError, ZeroSessionCloseFailedError, ZeroTimeoutError, ZeroValidationError, ZeroWalletError, asSchemaNode, coerceTempoChainId, createManagedAccount, extractInputEnvelope, isShortToken, normalizeTransportEnvelopeRequest, paymentHasAnchor, tempoChainLabelFromId, unwrapTransportEnvelope };
+//# sourceMappingURL=chunk-26IHUYNK.js.map
+//# sourceMappingURL=chunk-26IHUYNK.js.map