@blockrun/llm 3.21.0 → 3.22.0

package/dist/index.cjs

@@ -40,6 +40,7 @@ __export(index_exports, {
   BatchPaymentUnresolvedError: () => BatchPaymentUnresolvedError,
   BlockrunClient: () => BlockrunClient,
   BlockrunError: () => BlockrunError,
+  DEFAULT_BATCH_IN_DOUBT: () => DEFAULT_BATCH_IN_DOUBT,
   DEFAULT_BATCH_RATE_LIMIT: () => DEFAULT_BATCH_RATE_LIMIT,
   EVM_NETWORKS: () => EVM_NETWORKS,
   ImageClient: () => ImageClient,
@@ -103,6 +104,7 @@ __export(index_exports, {
   loadWallet: () => loadWallet,
   logCost: () => logCost,
   parsePaymentRequired: () => parsePaymentRequired,
+  readSettlement: () => readSettlement,
   retryDisposition: () => retryDisposition,
   saveSolanaWallet: () => saveSolanaWallet,
   saveToCache: () => saveToCache,
@@ -117,6 +119,8 @@ __export(index_exports, {
   solanaKeyToBytes: () => solanaKeyToBytes,
   solanaPublicKey: () => solanaPublicKey,
   status: () => status,
+  toWireSearchParameters: () => toWireSearchParameters,
+  toWireTools: () => toWireTools,
   validateMaxTokens: () => validateMaxTokens,
   validateModel: () => validateModel,
   validateTemperature: () => validateTemperature,
@@ -439,6 +443,122 @@ var ApiKeyAuth = class {
   }
 };
 
+// src/search-wire.ts
+function put(out, key, value) {
+  if (value !== void 0) out[key] = value;
+}
+function handles(list) {
+  return list?.map((h) => h.trim().replace(/^@+/, ""));
+}
+function sourceToWire(source) {
+  const raw = source;
+  const out = { ...raw };
+  for (const key of Object.keys(out)) if (/[A-Z]/.test(key)) delete out[key];
+  switch (source.type) {
+    case "x":
+      put(out, "included_x_handles", handles(source.includedXHandles) ?? out.included_x_handles);
+      put(out, "excluded_x_handles", handles(source.excludedXHandles) ?? out.excluded_x_handles);
+      put(out, "post_favorite_count", source.postFavoriteCount);
+      put(out, "post_view_count", source.postViewCount);
+      put(out, "enable_image_understanding", source.enableImageUnderstanding);
+      put(out, "enable_video_understanding", source.enableVideoUnderstanding);
+      break;
+    case "web":
+      put(out, "country", source.country);
+      put(out, "allowed_websites", source.allowedWebsites);
+      put(out, "excluded_websites", source.excludedWebsites);
+      put(out, "safe_search", source.safeSearch);
+      put(out, "enable_image_understanding", source.enableImageUnderstanding);
+      break;
+    case "news":
+      put(out, "country", source.country);
+      put(out, "allowed_websites", source.allowedWebsites);
+      put(out, "excluded_websites", source.excludedWebsites);
+      put(out, "safe_search", source.safeSearch);
+      break;
+    case "rss":
+      put(out, "links", source.links);
+      break;
+  }
+  return out;
+}
+function toWireSearchParameters(sp) {
+  const raw = sp;
+  const out = {};
+  for (const [key, value] of Object.entries(raw)) if (!/[A-Z]/.test(key) && key !== "sources") out[key] = value;
+  put(out, "mode", sp.mode);
+  if (sp.sources) out.sources = sp.sources.map(sourceToWire);
+  put(out, "return_citations", sp.returnCitations);
+  put(out, "from_date", sp.fromDate);
+  put(out, "to_date", sp.toDate);
+  put(out, "max_search_results", sp.maxSearchResults);
+  put(out, "max_turns", sp.maxTurns);
+  return out;
+}
+function toWireTools(tools) {
+  return tools.map((tool) => {
+    if (tool.type === "x_search") {
+      const out = { type: "x_search" };
+      put(out, "allowed_x_handles", handles(tool.allowedXHandles));
+      put(out, "excluded_x_handles", handles(tool.excludedXHandles));
+      put(out, "from_date", tool.fromDate);
+      put(out, "to_date", tool.toDate);
+      put(out, "enable_image_understanding", tool.enableImageUnderstanding);
+      put(out, "enable_video_understanding", tool.enableVideoUnderstanding);
+      return out;
+    }
+    if (tool.type === "web_search") {
+      const out = { type: "web_search" };
+      put(out, "allowed_domains", tool.allowedDomains);
+      put(out, "excluded_domains", tool.excludedDomains);
+      put(out, "enable_image_understanding", tool.enableImageUnderstanding);
+      return out;
+    }
+    return tool;
+  });
+}
+
+// src/receipt.ts
+function atomicToUsd(amount) {
+  return typeof amount === "string" && /^\d+$/.test(amount) ? Number(amount) / 1e6 : void 0;
+}
+function receiptChargedUsd(receipt) {
+  return atomicToUsd(receipt?.extra?.chargedAmount) ?? atomicToUsd(receipt?.amount);
+}
+function decode(header) {
+  try {
+    const json = typeof Buffer !== "undefined" ? Buffer.from(header, "base64").toString("utf8") : atob(header);
+    const parsed = JSON.parse(json);
+    return parsed && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readSettlement(response, quotedUsd, scheme) {
+  const header = response.headers.get("PAYMENT-RESPONSE") ?? response.headers.get("X-PAYMENT-RESPONSE");
+  const receipt = header ? decode(header) : void 0;
+  const extra = receipt?.extra;
+  const costUsd = receiptChargedUsd({
+    amount: receipt?.amount,
+    extra: extra && typeof extra === "object" ? extra : void 0
+  }) ?? quotedUsd;
+  const receiptTx = typeof receipt?.transaction === "string" && receipt.transaction ? receipt.transaction : void 0;
+  const transaction = receiptTx ?? (response.headers.get("X-Payment-Receipt")?.trim() || void 0);
+  const settlement = {
+    scheme,
+    quotedUsd,
+    ...transaction ? { transaction } : {},
+    ...typeof receipt?.network === "string" ? { network: receipt.network } : {},
+    ...receipt?.success === false ? { success: false } : {}
+  };
+  return { costUsd, settlement };
+}
+function withCost(body, response, bookedUsd, scheme) {
+  body.costUsd = bookedUsd;
+  body.settlement = readSettlement(response, bookedUsd, scheme).settlement;
+  return body;
+}
+
 // src/client.ts
 var import_accounts2 = require("viem/accounts");
 
@@ -4225,6 +4345,11 @@ function errSummary(err) {
   }
   return String(err).slice(0, 100);
 }
+function requestsSearch(options) {
+  if (options.tools?.some((tool) => tool.type === "x_search" || tool.type === "web_search")) return true;
+  if (options.searchParameters !== void 0) return options.searchParameters.mode !== "off";
+  return options.search === true;
+}
 function routingProfileForModel(model) {
   return AUTO_ROUTING_PROFILES[model.toLowerCase()];
 }
@@ -4252,7 +4377,7 @@ function routingText(messages) {
   };
 }
 function routeWithCatalog(prompt, systemPrompt, maxOutputTokens, modelPricing, options = {}) {
-  const tools = options.tools ?? [];
+  const tools = (options.tools ?? []).filter((tool) => tool.type === "function");
   const requiresTools = options.toolChoice === "none" ? false : options.toolChoice === "required" || typeof options.toolChoice === "object" ? true : void 0;
   const decision = route(prompt, systemPrompt, maxOutputTokens, {
     config: DEFAULT_ROUTING_CONFIG,
@@ -4272,6 +4397,15 @@ function routeWithCatalog(prompt, systemPrompt, maxOutputTokens, modelPricing, o
     const resolved = !id.startsWith("free/") ? id : modelPricing.has(`nvidia/${id.slice(5)}`) ? `nvidia/${id.slice(5)}` : null;
     if (resolved && !callable.includes(resolved)) callable.push(resolved);
   }
+  if (requestsSearch(options)) {
+    const searchable = callable.filter((id) => id.startsWith("xai/"));
+    if (searchable.length === 0) {
+      throw new Error(
+        `Search (x_search / web_search tools or searchParameters) runs on xai/* models only, and the ${options.routingProfile ?? "auto"} route has no xai/* candidate for this request. Call an xai/* model directly (e.g. xai/grok-4.3) or drop the search options.`
+      );
+    }
+    callable.splice(0, callable.length, ...searchable);
+  }
   const estimatedInputTokens = Math.ceil(
     Math.max(options.conversationChars ?? 0, `${systemPrompt ?? ""} ${prompt}`.length) / 4
   );
@@ -4690,7 +4824,7 @@ function getCostSummary() {
 }
 
 // src/version.ts
-var SDK_VERSION = "3.21.0";
+var SDK_VERSION = "3.22.0";
 var USER_AGENT = `blockrun-ts/${SDK_VERSION}`;
 
 // src/client.ts
@@ -4836,7 +4970,9 @@ var LLMClient = class _LLMClient {
       options?.maxOutputTokens ?? options?.maxTokens ?? DEFAULT_MAX_TOKENS,
       {
         routingProfile: options?.routingProfile,
-        requiresStructuredOutput: options?.responseFormat !== void 0
+        requiresStructuredOutput: options?.responseFormat !== void 0,
+        search: options?.search,
+        searchParameters: options?.searchParameters
       }
     );
   }
@@ -4903,6 +5039,8 @@ var LLMClient = class _LLMClient {
         requiresStructuredOutput: options.responseFormat !== void 0,
         tools: options.tools,
         toolChoice: options.toolChoice,
+        search: options.search,
+        searchParameters: options.searchParameters,
         conversationChars,
         hasVision
       }
@@ -4917,6 +5055,7 @@ var LLMClient = class _LLMClient {
       toolChoice: options.toolChoice,
       responseFormat: options.responseFormat,
       stop: options.stop,
+      timeout: options.timeout,
       // An explicit caller-supplied chain wins over the routed one.
       fallbackModels: options.fallbackModels ?? decision.fallbacks
     });
@@ -4993,11 +5132,11 @@ var LLMClient = class _LLMClient {
       if (options?.temperature !== void 0) body.temperature = options.temperature;
       if (options?.topP !== void 0) body.top_p = options.topP;
       if (options?.searchParameters !== void 0) {
-        body.search_parameters = options.searchParameters;
+        body.search_parameters = toWireSearchParameters(options.searchParameters);
       } else if (options?.search === true) {
         body.search_parameters = { mode: "on" };
       }
-      if (options?.tools !== void 0) body.tools = options.tools;
+      if (options?.tools !== void 0) body.tools = toWireTools(options.tools);
       if (options?.toolChoice !== void 0) body.tool_choice = options.toolChoice;
       if (options?.responseFormat !== void 0) body.response_format = options.responseFormat;
       if (options?.stop !== void 0) body.stop = options.stop;
@@ -5008,7 +5147,7 @@ var LLMClient = class _LLMClient {
     for (let i = 0; i < chain.length; i++) {
       const candidate = chain[i];
       try {
-        return await this.requestWithPayment("/v1/chat/completions", buildBody(candidate));
+        return await this.requestWithPayment("/v1/chat/completions", buildBody(candidate), options?.timeout);
       } catch (err) {
         lastErr = err;
         const next = chain[i + 1];
@@ -5079,19 +5218,19 @@ var LLMClient = class _LLMClient {
    * is `"paid-or-in-doubt"`. With an API key the request itself is billed, so
    * only the account API's explicit 4xx refusal is `"unpaid"`.
    */
-  async requestWithPayment(endpoint, body) {
+  async requestWithPayment(endpoint, body, timeoutMs) {
     const url = `${this.apiUrl}${endpoint}`;
     const unpaid = {
       method: "POST",
       headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT },
       body: JSON.stringify(body)
     };
-    const response = await this.sendUnpaid(url, unpaid);
+    const response = await this.sendUnpaid(url, unpaid, timeoutMs);
     if (response.status === 502 || response.status === 503) {
       await new Promise((r) => setTimeout(r, 1e3));
-      const retryResp = await this.sendUnpaid(url, unpaid);
+      const retryResp = await this.sendUnpaid(url, unpaid, timeoutMs);
       if (retryResp.status !== 502 && retryResp.status !== 503) {
-        if (retryResp.status === 402) return this.handlePaymentAndRetry(url, body, retryResp);
+        if (retryResp.status === 402) return this.handlePaymentAndRetry(url, body, retryResp, timeoutMs);
         if (!retryResp.ok) {
           let errorBody;
           try {
@@ -5108,7 +5247,7 @@ var LLMClient = class _LLMClient {
       }
     }
     if (response.status === 402) {
-      return this.handlePaymentAndRetry(url, body, response);
+      return this.handlePaymentAndRetry(url, body, response, timeoutMs);
     }
     if (!response.ok) {
       let errorBody;
@@ -5133,9 +5272,9 @@ var LLMClient = class _LLMClient {
    * {@link RetryDisposition}: `"unpaid"` with a wallet; with an API key, see
    * {@link accountErrorDisposition} (the request itself is billed).
    */
-  async sendUnpaid(url, init) {
+  async sendUnpaid(url, init, timeoutMs) {
     try {
-      return await this.fetchWithTimeout(url, init);
+      return await this.fetchWithTimeout(url, init, timeoutMs);
     } catch (err) {
       throw withDisposition(err, this.apiAuth ? accountErrorDisposition(err) : "unpaid");
     }
@@ -5143,13 +5282,22 @@ var LLMClient = class _LLMClient {
   /**
    * Parse a response to a request that carried no payment: the free tier,
    * or, with an API key, the billed request itself.
+   *
+   * With a wallet nothing was paid, so `costUsd` is 0 (a free model). With an
+   * API key the call is billed to the account and `costUsd` stays undefined.
    */
   async parseUnpaidChatResponse(response) {
+    let served;
     try {
-      return await this.parseChatResponse(response);
+      served = await this.parseChatResponse(response);
     } catch (err) {
       throw withDisposition(err, this.apiAuth ? "paid-or-in-doubt" : "unpaid");
     }
+    if (!this.apiAuth) {
+      served.costUsd = 0;
+      served.settlement = { scheme: "free", quotedUsd: 0 };
+    }
+    return served;
   }
   /**
    * Handle 402 response: parse requirements, sign payment, retry.
@@ -5157,7 +5305,7 @@ var LLMClient = class _LLMClient {
    * Anything thrown before the signed payment is sent is `"unpaid"`; anything
    * after it, `"paid-or-in-doubt"` (see {@link RetryDisposition}).
    */
-  async handlePaymentAndRetry(url, body, response) {
+  async handlePaymentAndRetry(url, body, response, timeoutMs) {
     let signed;
     try {
       signed = await this.signFrom402(url, response);
@@ -5165,7 +5313,7 @@ var LLMClient = class _LLMClient {
       throw withDisposition(err, "unpaid");
     }
     try {
-      return await this.sendPaid(url, body, signed.paymentPayload, signed.details);
+      return await this.sendPaid(url, body, signed.paymentPayload, signed.details, timeoutMs);
     } catch (err) {
       throw withDisposition(err, "paid-or-in-doubt");
     }
@@ -5210,7 +5358,7 @@ var LLMClient = class _LLMClient {
     return { paymentPayload, details };
   }
   /** Send the signed payment and read the answer. The payment may settle from here on. */
-  async sendPaid(url, body, paymentPayload, details) {
+  async sendPaid(url, body, paymentPayload, details, timeoutMs) {
     const retryResponse = await this.fetchWithTimeout(url, {
       method: "POST",
       headers: {
@@ -5219,7 +5367,7 @@ var LLMClient = class _LLMClient {
         "PAYMENT-SIGNATURE": paymentPayload
       },
       body: JSON.stringify(body)
-    });
+    }, timeoutMs);
     if (retryResponse.status === 502 || retryResponse.status === 503) {
       await new Promise((r) => setTimeout(r, 1e3));
       const retryResp2 = await this.fetchWithTimeout(url, {
@@ -5230,7 +5378,7 @@ var LLMClient = class _LLMClient {
           "PAYMENT-SIGNATURE": paymentPayload
         },
         body: JSON.stringify(body)
-      });
+      }, timeoutMs);
       if (retryResp2.status !== 502 && retryResp2.status !== 503) {
         if (retryResp2.status === 402) throw new PaymentError("Payment was rejected. Check your wallet balance.");
         if (!retryResp2.ok) {
@@ -5246,7 +5394,7 @@ var LLMClient = class _LLMClient {
         this.sessionCalls += 1;
         this.sessionTotalUsd += costUsd2;
         this.recordCost(url, costUsd2, { body, network: details.network });
-        return this.parseChatResponse(retryResp2);
+        return withCost(await this.parseChatResponse(retryResp2), retryResp2, costUsd2, "exact");
       }
     }
     if (retryResponse.status === 402) {
@@ -5269,7 +5417,7 @@ var LLMClient = class _LLMClient {
     this.sessionCalls += 1;
     this.sessionTotalUsd += costUsd;
     this.recordCost(url, costUsd, { body, network: details.network });
-    return this.parseChatResponse(retryResponse);
+    return withCost(await this.parseChatResponse(retryResponse), retryResponse, costUsd, "exact");
   }
   /**
    * Sign a payment header and return the PAYMENT-SIGNATURE value.
@@ -5339,7 +5487,7 @@ var LLMClient = class _LLMClient {
     };
     if (options?.temperature !== void 0) body.temperature = options.temperature;
     if (options?.topP !== void 0) body.top_p = options.topP;
-    if (options?.tools !== void 0) body.tools = options.tools;
+    if (options?.tools !== void 0) body.tools = toWireTools(options.tools);
     if (options?.toolChoice !== void 0) body.tool_choice = options.toolChoice;
     if (options?.responseFormat !== void 0) body.response_format = options.responseFormat;
     if (options?.stop !== void 0) body.stop = options.stop;
@@ -5737,11 +5885,11 @@ var LLMClient = class _LLMClient {
     return retryResponse.json();
   }
   /**
-   * Fetch with timeout.
+   * Fetch with timeout: `timeoutMs` (a per-call override), else the client's `timeout`.
    */
-  async fetchWithTimeout(url, options) {
+  async fetchWithTimeout(url, options, timeoutMs = this.timeout) {
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     try {
       const response = await (this.apiAuth ? this.apiAuth.fetch.bind(this.apiAuth) : fetch)(url, {
         ...options,
@@ -9726,6 +9874,7 @@ var import_bs582 = __toESM(require("bs58"), 1);
 var BATCH_SCHEME = "batch-settlement";
 var BLOCKRUN_SOL_OPERATOR = "5YKPQUFjw5WQqhSUkEGKNNfYYVqnRRNbpYyL71qQ1vm3";
 var DEFAULT_BATCH_RATE_LIMIT = { maxAttempts: 3, maxWaitMs: 6e4 };
+var DEFAULT_BATCH_IN_DOUBT = { maxWaitMs: 3e5 };
 var BatchPaymentUnresolvedError = class extends PaymentError {
   /** The {@link SolanaBatchEvent.reason} of the `unresolved` event reported with it. */
   reason;
@@ -10402,6 +10551,46 @@ function withoutClientSignedBatch(paymentRequired) {
   const accepts = paymentRequired.accepts ?? [];
   return accepts.some(clientSignedBatch) ? { ...paymentRequired, accepts: accepts.filter((accept) => !clientSignedBatch(accept)) } : paymentRequired;
 }
+var PAYMENT_IDENTIFIER = "payment-identifier";
+function withPaymentIdentifier(paymentRequired) {
+  const declared = paymentRequired.extensions?.[PAYMENT_IDENTIFIER];
+  if (typeof declared?.info?.required !== "boolean") return paymentRequired;
+  const id = `pay_${(0, import_crypto2.randomUUID)().replace(/-/g, "")}`;
+  return {
+    ...paymentRequired,
+    extensions: { ...paymentRequired.extensions, [PAYMENT_IDENTIFIER]: { ...declared, info: { ...declared.info, id } } }
+  };
+}
+function peekReceipt(http, getHeader) {
+  try {
+    return http.getPaymentSettleResponse(getHeader);
+  } catch {
+    return void 0;
+  }
+}
+function receiptSucceeded(http, answer) {
+  return peekReceipt(http, (name) => answer.headers.get(name))?.success === true;
+}
+function hasPaymentIdentifier(payload) {
+  const info = payload.extensions?.[PAYMENT_IDENTIFIER]?.info;
+  return typeof info?.id === "string";
+}
+var IN_DOUBT_MIN_WAIT_MS = 1e3;
+var IN_DOUBT_MAX_WAIT_MS = 3e4;
+function replayMayResolve(doubt) {
+  if (doubt.unanswered) return true;
+  const answer = doubt.held;
+  if (!answer) return false;
+  return answer.status >= 500 || answer.status === 429 || answer.status === 409 && Boolean(answer.headers.get("retry-after")?.trim());
+}
+function inDoubtWait(doubt, replay) {
+  const asked = doubt.held ? parseRetryAfter(doubt.held.headers.get("retry-after")) : void 0;
+  return Math.min(IN_DOUBT_MAX_WAIT_MS, Math.max(IN_DOUBT_MIN_WAIT_MS, asked ?? backoffDelay(replay)));
+}
+function replayDoubt(outcome) {
+  if (outcome.kind === "charged" || outcome.kind === "in_doubt") return outcome;
+  return { kind: "in_doubt", reason: "replay_unresolved", replayable: false, settled: true, detail: "the replay was refused" };
+}
 function trustedBatchAccepts(paymentRequired, operators) {
   return (paymentRequired.accepts ?? []).filter((candidate) => {
     const extra = candidate.extra;
@@ -10411,9 +10600,6 @@ function trustedBatchAccepts(paymentRequired, operators) {
 function trustedBatchAccept(paymentRequired, operators) {
   return trustedBatchAccepts(paymentRequired, operators)[0];
 }
-function atomicToUsd(amount) {
-  return typeof amount === "string" && /^\d+$/.test(amount) ? Number(amount) / 1e6 : void 0;
-}
 function chargedUsd(getReceipt) {
   let receipt;
   try {
@@ -10421,7 +10607,7 @@ function chargedUsd(getReceipt) {
   } catch {
     return 0;
   }
-  return atomicToUsd(receipt?.extra?.chargedAmount) ?? atomicToUsd(receipt?.amount) ?? 0;
+  return receiptChargedUsd(receipt) ?? 0;
 }
 function rebuiltCharge(settled, payload) {
   if (settled?.success !== true) return 0n;
@@ -10541,13 +10727,42 @@ function parseRetryAfter(value, now = Date.now()) {
   }
   return Number.isFinite(ms) && ms <= MAX_RETRY_AFTER_MS ? ms : void 0;
 }
-var NOT_BROADCAST_429 = /* @__PURE__ */ new Set([
+var NOT_BROADCAST_REFUSALS = /* @__PURE__ */ new Set([
+  // 429
   "batch_account_channel_capacity_exhausted",
   "batch_channel_capacity_exhausted",
-  "batch_deposit_rate_limited"
+  "batch_deposit_rate_limited",
+  "batch_deposit_ip_rate_limited",
+  // 503
+  "batch_signer_funding_headroom_exhausted",
+  "batch_new_channels_disabled",
+  "batch_public_new_channels_disabled",
+  // 403
+  "batch_account_admission_paused",
+  "batch_channel_owner_mismatch",
+  "batch_fee_payer_unavailable",
+  "batch_fee_payer_not_dedicated",
+  "batch_fee_payer_lane_not_authorized",
+  "batch_transaction_fee_payer_mismatch",
+  // 400
+  "batch_initial_deposit_out_of_range",
+  "batch_deposit_asset_not_supported",
+  "batch_withdraw_delay_out_of_range"
 ]);
 function provesNothingBroadcast(receipt) {
-  return receipt?.success === false && !receipt.transaction && typeof receipt.errorReason === "string" && NOT_BROADCAST_429.has(receipt.errorReason);
+  return receipt?.success === false && !receipt.transaction && typeof receipt.errorReason === "string" && NOT_BROADCAST_REFUSALS.has(receipt.errorReason);
+}
+var CONFIG_REFUSALS = /* @__PURE__ */ new Set([
+  "batch_initial_deposit_out_of_range",
+  "batch_deposit_asset_not_supported",
+  "batch_withdraw_delay_out_of_range"
+]);
+var REFUSAL_COOLDOWN_MS = 6e4;
+var CONFIG_REFUSAL_COOLDOWN_MS = 10 * 6e4;
+var REFUSAL_COOLDOWN_MAX_MS = 15 * 6e4;
+function refusalCooldownMs(errorReason, retryAfterMs2) {
+  if (retryAfterMs2 !== void 0) return Math.min(retryAfterMs2, REFUSAL_COOLDOWN_MAX_MS);
+  return errorReason !== void 0 && CONFIG_REFUSALS.has(errorReason) ? CONFIG_REFUSAL_COOLDOWN_MS : REFUSAL_COOLDOWN_MS;
 }
 function backoffDelay(attempt) {
   const base = 1e3 * 2 ** Math.max(0, attempt - 1);
@@ -10680,7 +10895,7 @@ function intentTarget(intent) {
 var SolanaBatchPayer = class {
   constructor(init) {
     this.init = init;
-    const { operators, rateLimit } = init.options;
+    const { operators, rateLimit, inDoubt } = init.options;
     if (!Array.isArray(operators) || operators.length === 0 || operators.some((o) => typeof o !== "string" || !o)) {
       throw new Error("batch.operators must list at least one base58 operator public key");
     }
@@ -10692,11 +10907,16 @@ var SolanaBatchPayer = class {
     if (!Number.isFinite(this.maxWaitMs) || this.maxWaitMs < 0) {
       throw new Error("batch.rateLimit.maxWaitMs must be a finite number of ms >= 0");
     }
+    this.inDoubtMaxWaitMs = inDoubt?.maxWaitMs ?? DEFAULT_BATCH_IN_DOUBT.maxWaitMs;
+    if (!Number.isFinite(this.inDoubtMaxWaitMs) || this.inDoubtMaxWaitMs < 0) {
+      throw new Error("batch.inDoubt.maxWaitMs must be a finite number of ms >= 0");
+    }
   }
   init;
   state;
   maxAttempts;
   maxWaitMs;
+  inDoubtMaxWaitMs;
   counters = {
     fallbacks: 0,
     fallbacksByReason: {},
@@ -11065,14 +11285,19 @@ var SolanaBatchPayer = class {
    *   the call's result (`served`, nothing paid); one that fails otherwise
    *   is the call's error (`failed`, `"unpaid"`), never an exact payment
    *   against the stale challenge;
-   * - in doubt: ends only with a definitive success receipt from the one
-   *   replay a receipt-less 429 is allowed ({@link resolveInDoubt}), or a
-   *   thrown {@link BatchPaymentUnresolvedError}. No new authorization, no
-   *   new deposit, no exact payment and no fallback model is ever paid for a
-   *   call in doubt.
+   * - in doubt: ends only with a definitive success receipt from a replay
+   *   of the identical payment ({@link resolveInDoubt}: the one replay a
+   *   receipt-less 429 is allowed, or the replays of a payment carrying a
+   *   payment identifier while the gateway says one can succeed, within
+   *   `inDoubt.maxWaitMs`), or a thrown {@link BatchPaymentUnresolvedError}.
+   *   No new authorization, no new deposit, no exact payment and no fallback
+   *   model is ever paid for a call in doubt.
    *
    * The wallet stays in cooldown after a 429, so its other calls wait
-   * instead of sending opens of their own.
+   * instead of sending opens of their own. After a deposit the facilitator
+   * refused before broadcasting it (a 402 with a failed `batch_*` admission
+   * receipt), its calls do not wait: they pay exact at once
+   * (`admission_refused`) until the refusal cooldown ends.
    *
    * @param closesAtStart - {@link closeFence}, taken before the call's first
    *   (unpaid) request. If a close completed since, the call pays exact
@@ -11136,6 +11361,15 @@ var SolanaBatchPayer = class {
     try {
       for (; ; ) {
         const now = Date.now();
+        if ((wallet.refusedUntil ?? 0) > now) {
+          return fallback({
+            reason: "admission_refused",
+            errorReason: wallet.refusedFor,
+            retryAfterMs: (wallet.refusedUntil ?? 0) - now,
+            attempt: budget.attempt,
+            detail: `the facilitator refused this wallet's last batch deposit (${wallet.refusedFor ?? "unknown"}); batch is skipped until the refusal cooldown ends`
+          });
+        }
         if (wallet.cooldownUntil > now && wallet.cooldownUntil !== waitedUntil) {
           const wait = wallet.cooldownUntil - now;
           if (budget.waited + wait > this.maxWaitMs) {
@@ -11225,12 +11459,23 @@ var SolanaBatchPayer = class {
           if (built.kind !== "authorization") {
             if (outcome.depositSafe) this.forgetIntent(wallet, built.key);
             else this.distrust(wallet, built, "deposit_refused");
+            if (outcome.refusedForMs !== void 0) {
+              const until = Date.now() + outcome.refusedForMs;
+              if (until > (wallet.refusedUntil ?? 0)) {
+                wallet.refusedUntil = until;
+                wallet.refusedFor = outcome.errorReason;
+              }
+            }
           }
           sent = void 0;
           release();
           if (!outcome.rateLimited) {
-            const { kind: _kind, rateLimited: _limited, depositSafe: _safe, ...event } = outcome;
-            return fallback({ ...event, attempt: budget.attempt });
+            const { kind: _kind, rateLimited: _limited, depositSafe: _safe, refusedForMs, ...event } = outcome;
+            return fallback({
+              ...event,
+              ...refusedForMs !== void 0 && built.kind !== "authorization" ? { retryAfterMs: refusedForMs } : {},
+              attempt: budget.attempt
+            });
           }
           const wait = this.coolDown(wallet, outcome.rateLimited.retryAfterMs ?? backoffDelay(budget.attempt));
           if (budget.attempt >= this.maxAttempts || budget.waited + wait > this.maxWaitMs) {
@@ -11276,7 +11521,7 @@ var SolanaBatchPayer = class {
           if (built.kind !== "authorization" && !(built.key && wallet.resyncs.has(built.key))) this.forgetIntent(wallet, built.key);
           sent = void 0;
           release();
-          await this.report({ type: "recovered", reason: "rate_limited", attempt: budget.attempt });
+          await this.report({ type: "recovered", reason: outcome.status === 429 ? "rate_limited" : "in_doubt", attempt: budget.attempt });
           return { kind: "paid", response: resolved.response, chargedUsd: resolved.chargedUsd };
         }
         return await this.raiseUnresolved(wallet, built, resolved, budget.attempt);
@@ -11325,21 +11570,24 @@ var SolanaBatchPayer = class {
   /**
    * Try to end a payment in doubt with the gateway's own word.
    *
-   * The one source of evidence this SDK accepts today is a definitive
-   * success receipt on the single byte-identical replay a 429 without a
-   * receipt is allowed, after its backoff (the owner's bounded safety
-   * attempt). Any other answer to it (a 402 or `duplicate_settlement`, which
-   * mean the original reached the gateway; another 429; a 5xx; a timeout)
-   * leaves it in doubt. Every other in-doubt outcome is never replayed.
+   * The one source of evidence this SDK accepts is a definitive success
+   * receipt on a byte-identical replay of the payment. Any other answer to a
+   * replay (a 402 or `duplicate_settlement`, which mean the original reached
+   * the gateway; a 409; another 429; a 5xx; a timeout) leaves it in doubt.
+   *
+   * - A payment carrying a payment identifier is replayed for as long as
+   *   the gateway says a later replay can succeed ({@link replayInDoubt}).
+   * - Any other payment gets a replay only after a 429 without a receipt:
+   *   one, after its backoff (the owner's bounded safety attempt), within
+   *   `rateLimit`. Every other in-doubt outcome is never replayed.
    *
    * Chain state is not evidence here: it can settle a deposit (see
-   * `resync`), never whether the gateway charged. Gateway-side evidence (a
-   * receipt on every response, a request-status endpoint with a fence)
-   * plugs in here, before the caller raises.
+   * `resync`), never whether the gateway charged.
    *
    * @returns the charged replay, or the doubt to raise.
    */
   async resolveInDoubt(wallet, sent, doubt, send, budget) {
+    if (hasPaymentIdentifier(sent.payload)) return this.replayInDoubt(wallet, sent, doubt, send, budget.attempt);
     if (!doubt.replayable) return doubt;
     const wait = this.coolDown(wallet, doubt.retryAfterMs ?? backoffDelay(budget.attempt));
     if (budget.attempt >= this.maxAttempts || budget.waited + wait > this.maxWaitMs) {
@@ -11359,9 +11607,94 @@ var SolanaBatchPayer = class {
     budget.waited += wait;
     await sleep2(wait);
     budget.attempt += 1;
-    const replayed = await this.sendOnce(wallet, sent, send, true, true);
-    if (replayed.kind === "charged") return replayed;
-    return replayed.kind === "in_doubt" ? replayed : { kind: "in_doubt", reason: "replay_unresolved", replayable: false, settled: true, detail: "the replay was refused" };
+    return replayDoubt(await this.sendOnce(wallet, sent, send, true, true));
+  }
+  /**
+   * Replay a payment in doubt that carries a payment identifier until the
+   * gateway's answer settles it.
+   *
+   * A gateway that declares `payment-identifier` stores each paid response
+   * under its identifier and answers a byte-identical replay of a completed
+   * request with it, the original receipt included; while the original is
+   * still running, it answers 409 with a `Retry-After`. So the identical
+   * payment (the same `PAYMENT-SIGNATURE` header and the same body) is
+   * replayed for as long as the last answer says a later one can succeed
+   * ({@link replayMayResolve}), after {@link inDoubtWait} each time, as long
+   * as the wait fits in `inDoubt.maxWaitMs`, counted from the first doubt:
+   * every wait (as long as it really took) and every replay's round trip. A
+   * replay already sent is not cut short. These replays do not count
+   * against `rateLimit`; a 429 among them still puts the wallet in cooldown.
+   *
+   * Every answer that does not settle it is held back from the scheme
+   * ({@link InDoubt.held}) and handed over only once no replay follows, so
+   * the scheme rolls the payment back once, or takes the receipt that answer
+   * carries. That is the last answer, unless an earlier one carried a
+   * success receipt and the later ones do not: a success receipt is the
+   * gateway's word that it charged, and handing the scheme a receipt-less
+   * refusal of a replay instead would roll a real charge back and desync the
+   * channel's cumulative.
+   *
+   * @returns the charged replay, or the doubt to raise.
+   */
+  async replayInDoubt(wallet, sent, first, send, attempt) {
+    let doubt = first;
+    let held = first.held;
+    let heldSucceeded = held !== void 0 && receiptSucceeded(sent.http, held);
+    let replays = 0;
+    let spent = 0;
+    const stop = async (note) => {
+      if (!doubt.settled && held) {
+        const answer = held;
+        await this.settle(sent.http, sent.payload, (name) => answer.headers.get(name), answer.status);
+      }
+      const notes = [replays > 0 ? `${replays} replay${replays === 1 ? "" : "s"} did not resolve it` : "", note ?? ""];
+      return {
+        ...doubt,
+        settled: doubt.settled || held !== void 0,
+        held: void 0,
+        firstReason: first.reason,
+        detail: [doubt.detail, ...notes].filter(Boolean).join("; ")
+      };
+    };
+    for (; ; ) {
+      if (!replayMayResolve(doubt)) {
+        return stop(doubt.held?.status === 409 ? "the gateway sent no Retry-After, so no replay can resolve it" : void 0);
+      }
+      const wait = inDoubtWait(doubt, replays + 1);
+      const status2 = doubt.held?.status;
+      if (status2 === 429) this.coolDown(wallet, (doubt.held && parseRetryAfter(doubt.held.headers.get("retry-after"))) ?? wait);
+      if (spent + wait > this.inDoubtMaxWaitMs) {
+        return stop(`batch.inDoubt.maxWaitMs (${this.inDoubtMaxWaitMs} ms) leaves no room for ${replays > 0 ? "another replay" : "a replay"}`);
+      }
+      await this.report({
+        type: "backoff",
+        reason: status2 === 429 ? "rate_limited" : "in_doubt",
+        status: status2,
+        errorReason: doubt.errorReason,
+        retryAfterMs: wait,
+        attempt,
+        detail: `replay ${replays + 1} of the payment in doubt`
+      });
+      const sleptFrom = Date.now();
+      await sleep2(wait);
+      spent += Math.max(wait, Date.now() - sleptFrom);
+      replays += 1;
+      const startedAt = Date.now();
+      const replayed = replayDoubt(await this.sendOnce(wallet, sent, send, true, true));
+      spent += Math.max(0, Date.now() - startedAt);
+      if (replayed.kind === "charged") return replayed;
+      doubt = replayed;
+      if (doubt.held) {
+        const succeeded = receiptSucceeded(sent.http, doubt.held);
+        if (succeeded || !heldSucceeded) {
+          held = doubt.held;
+          heldSucceeded = succeeded;
+        }
+      } else if (doubt.settled) {
+        held = void 0;
+        heldSucceeded = false;
+      }
+    }
   }
   /**
    * Raise a payment in doubt: release the scheme's hold on it (the channel
@@ -11372,10 +11705,11 @@ var SolanaBatchPayer = class {
   async raiseUnresolved(wallet, sent, doubt, attempt) {
     if (!doubt.settled) await this.settle(sent.http, sent.payload, () => null, 0);
     if (sent.kind !== "authorization") {
+      const reason = doubt.firstReason ?? doubt.reason;
       this.distrust(
         wallet,
         sent,
-        doubt.reason === "no_response" ? "deposit_unanswered" : doubt.reason === "replay_unresolved" ? "deposit_rate_limited" : "deposit_failed"
+        reason === "no_response" ? "deposit_unanswered" : reason === "replay_unresolved" ? "deposit_rate_limited" : "deposit_failed"
       );
     }
     await this.report({
@@ -11462,8 +11796,8 @@ var SolanaBatchPayer = class {
    * here, and only for a first send.
    *
    * @param retry - count this send in `retries` (it follows this call's own 429).
-   * @param replay - this is the one replay of a receipt-less 429: only a 2xx
-   *   with a success receipt counts, everything else stays in doubt.
+   * @param replay - this is a replay of a payment in doubt: only a 2xx with
+   *   a success receipt counts, everything else stays in doubt.
    */
   async sendOnce(wallet, sent, send, retry, replay) {
     if (retry) this.counters.retries += 1;
@@ -11477,6 +11811,7 @@ var SolanaBatchPayer = class {
         reason: replay ? "replay_unresolved" : "no_response",
         replayable: false,
         settled: false,
+        unanswered: true,
         detail: `${replay ? "the replay" : "the payment"} got no answer (${err instanceof Error ? `${err.name}: ${err.message}` : String(err)})`,
         cause: err
       };
@@ -11501,6 +11836,7 @@ var SolanaBatchPayer = class {
     const getHeader = (name) => response.headers.get(name);
     const receipted = Boolean(getHeader("PAYMENT-RESPONSE") || getHeader("X-PAYMENT-RESPONSE"));
     const status2 = response.status;
+    const hold = hasPaymentIdentifier(payload) && (!response.ok || replay && peekReceipt(http, getHeader)?.success !== true);
     if (status2 === 429 && !receipted) {
       return {
         kind: "in_doubt",
@@ -11510,12 +11846,27 @@ var SolanaBatchPayer = class {
         status: status2,
         retryAfterMs: parseRetryAfter(getHeader("retry-after")),
         errorReason: await rateLimitReason(response, void 0),
-        detail: replay ? "the replay was answered 429 without a receipt" : "a 429 without a receipt"
+        detail: replay ? "the replay was answered 429 without a receipt" : "a 429 without a receipt",
+        ...hold ? { held: response } : {}
       };
     }
+    const outcome = await this.classifyAnswer(wallet, sent, response, replay, hold);
+    if (!hold) return outcome;
+    if (outcome.kind === "in_doubt") return { ...outcome, settled: false, held: response };
+    await this.settle(http, payload, getHeader, status2);
+    return outcome;
+  }
+  /**
+   * {@link classify}, past a receipt-less 429. With `hold`, the answer is not
+   * handed to the scheme: its receipt is only read.
+   */
+  async classifyAnswer(wallet, sent, response, replay, hold) {
+    const { http, payload } = sent;
+    const getHeader = (name) => response.headers.get(name);
+    const status2 = response.status;
     const channelId = payloadChannelId(payload);
     const before = channelId ? confirmedState(wallet.book.find(channelId)?.record) : void 0;
-    const reconciled = await this.settle(http, payload, getHeader, status2);
+    const reconciled = hold ? { settleResponse: peekReceipt(http, getHeader), ok: false } : await this.settle(http, payload, getHeader, status2);
     const receipt = reconciled.settleResponse;
     const definitive = receipt?.success === true && reconciled.ok && recordAdvanced(before, channelId ? confirmedState(wallet.book.find(channelId)?.record) : void 0, payload, receipt);
     if (!response.ok && !replay && sent.kind === "authorization" && cancelledReceipt(receipt)) {
@@ -11578,7 +11929,15 @@ var SolanaBatchPayer = class {
             cause: await afterPaymentError(response)
           };
         }
-        return { kind: "not_charged", reason: "payment_required", status: status2, errorReason: receipt?.errorReason, depositSafe: provesNothingBroadcast(receipt) };
+        const refused = provesNothingBroadcast(receipt);
+        return {
+          kind: "not_charged",
+          reason: "payment_required",
+          status: status2,
+          errorReason: receipt?.errorReason,
+          depositSafe: refused,
+          ...refused ? { refusedForMs: refusalCooldownMs(receipt?.errorReason, parseRetryAfter(getHeader("retry-after"))) } : {}
+        };
       }
       const refusal = await batchRefusal(response);
       if (refusal) {
@@ -11609,7 +11968,7 @@ var SolanaBatchPayer = class {
       const http = (await this.build(wallet)).http;
       try {
         await this.prepareTopUp(wallet, paymentRequired);
-        return { http, payload: await http.createPaymentPayload(withoutClientSignedBatch(paymentRequired)) };
+        return { http, payload: await http.createPaymentPayload(withPaymentIdentifier(withoutClientSignedBatch(paymentRequired))) };
       } catch (err) {
         if (pass > 0 || !isResyncRequired(err) || wallet.resyncs.size === 0) throw err;
       } finally {
@@ -11702,13 +12061,7 @@ var SolanaBatchPayer = class {
       console.error(
         `[@blockrun/llm] batch-settlement receipt not reconciled: ${JSON.stringify(err instanceof Error ? err.message : String(err))}`
       );
-      let settleResponse;
-      try {
-        settleResponse = http.getPaymentSettleResponse(getHeader);
-      } catch {
-        settleResponse = void 0;
-      }
-      return { settleResponse, ok: false };
+      return { settleResponse: peekReceipt(http, getHeader), ok: false };
     }
   }
   /**
@@ -12091,9 +12444,9 @@ var SolanaLLMClient = class {
       };
       if (options?.temperature !== void 0) body.temperature = options.temperature;
       if (options?.topP !== void 0) body.top_p = options.topP;
-      if (options?.searchParameters !== void 0) body.search_parameters = options.searchParameters;
+      if (options?.searchParameters !== void 0) body.search_parameters = toWireSearchParameters(options.searchParameters);
       else if (options?.search === true) body.search_parameters = { mode: "on" };
-      if (options?.tools !== void 0) body.tools = options.tools;
+      if (options?.tools !== void 0) body.tools = toWireTools(options.tools);
       if (options?.toolChoice !== void 0) body.tool_choice = options.toolChoice;
       if (options?.responseFormat !== void 0) body.response_format = options.responseFormat;
       if (options?.stop !== void 0) body.stop = options.stop;
@@ -12104,7 +12457,7 @@ var SolanaLLMClient = class {
     for (let index = 0; index < chain.length; index += 1) {
       const candidate = chain[index];
       try {
-        return await this.requestWithPayment("/v1/chat/completions", buildBody(candidate));
+        return await this.requestWithPayment("/v1/chat/completions", buildBody(candidate), options?.timeout);
       } catch (error) {
         lastError = error;
         if (!isTransientError(error) || index === chain.length - 1) throw error;
@@ -12154,6 +12507,8 @@ var SolanaLLMClient = class {
       {
         routingProfile: options?.routingProfile,
         requiresStructuredOutput: options?.responseFormat !== void 0,
+        search: options?.search,
+        searchParameters: options?.searchParameters,
         minimumPaymentUsd: this.apiAuth ? 0 : SOLANA_MINIMUM_PAYMENT_USD
       }
     );
@@ -12181,6 +12536,8 @@ var SolanaLLMClient = class {
         requiresStructuredOutput: options.responseFormat !== void 0,
         tools: options.tools,
         toolChoice: options.toolChoice,
+        search: options.search,
+        searchParameters: options.searchParameters,
         conversationChars,
         hasVision,
         minimumPaymentUsd: this.apiAuth ? 0 : SOLANA_MINIMUM_PAYMENT_USD
@@ -12196,6 +12553,7 @@ var SolanaLLMClient = class {
       toolChoice: options.toolChoice,
       responseFormat: options.responseFormat,
       stop: options.stop,
+      timeout: options.timeout,
       // An explicit caller-supplied chain wins over the routed one.
       fallbackModels: options.fallbackModels ?? decision.fallbacks
     });
@@ -12333,7 +12691,7 @@ var SolanaLLMClient = class {
    *
    * @returns USDC balance as a float
    */
-  async getBalance() {
+  async getBalance(options) {
     const usdc_mint = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
     const address = await this.getWalletAddress();
     try {
@@ -12348,6 +12706,9 @@ var SolanaLLMClient = class {
         })
       });
       const data = await response.json();
+      if (options?.strict && (!response.ok || data.error)) {
+        throw new Error(`Solana RPC balance lookup failed: ${data.error?.message ?? `HTTP ${response.status}`}`);
+      }
       const accounts = data.result?.value || [];
       if (!accounts.length) return 0;
       let total = 0;
@@ -12355,7 +12716,8 @@ var SolanaLLMClient = class {
         total += acct.account?.data?.parsed?.info?.tokenAmount?.uiAmount || 0;
       }
       return total;
-    } catch {
+    } catch (error) {
+      if (options?.strict) throw error;
       return 0;
     }
   }
@@ -12630,15 +12992,16 @@ var SolanaLLMClient = class {
    * `"paid-or-in-doubt"`, and so is any error with an API key once the billed
    * request was sent, except the account API's explicit 4xx refusal.
    */
-  async requestWithPayment(endpoint, body) {
+  async requestWithPayment(endpoint, body, timeoutMs) {
     const url = `${this.apiUrl}${endpoint}`;
+    const json = JSON.stringify(body);
     const closesAtStart = await this.batchPayer?.closeFence();
     for (let staleRetries = 0; ; ) {
       const response = await this.sendUnpaid(url, {
         method: "POST",
         headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT },
-        body: JSON.stringify(body)
-      });
+        body: json
+      }, timeoutMs);
       if (response.status === 402) {
         try {
           let paymentRequired;
@@ -12654,16 +13017,16 @@ var SolanaLLMClient = class {
               (paymentHeaders) => this.fetchWithTimeout(url, {
                 method: "POST",
                 headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT, ...paymentHeaders },
-                body: JSON.stringify(body)
-              }),
+                body: json
+              }, timeoutMs),
               // A fresh, unpaid challenge after a 429 wait: the request itself,
               // sent again without a payment. Every error it throws is unpaid.
               async () => {
                 const challenge = await this.sendUnpaid(url, {
                   method: "POST",
                   headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT },
-                  body: JSON.stringify(body)
-                });
+                  body: json
+                }, timeoutMs);
                 if (challenge.status === 402) {
                   try {
                     return { kind: "challenge", paymentRequired: await this.readPaymentRequired(challenge) };
@@ -12678,13 +13041,14 @@ var SolanaLLMClient = class {
             );
             if (batch.kind === "paid") {
               this.recordSettlement(batch.chargedUsd);
-              return await this.readPaidJson(batch.response);
+              const paid = await this.readPaidJson(batch.response);
+              return withCost(paid, batch.response, batch.chargedUsd, "batch");
             }
-            if (batch.kind === "served") return await this.readUnpaidJson(batch.response);
+            if (batch.kind === "served") return this.withUnpaidCost(await this.readUnpaidJson(batch.response));
             if (batch.kind === "failed") throw batch.error;
             exactRequired = batch.paymentRequired ?? paymentRequired;
           }
-          return await this.handlePaymentAndRetry(url, body, exactRequired, staleRetries > 0);
+          return await this.handlePaymentAndRetry(url, json, exactRequired, staleRetries > 0, timeoutMs);
         } catch (error) {
           if (!(error instanceof SafeStaleBlockhashError) || staleRetries >= STALE_BLOCKHASH_RETRY_BACKOFFS_MS.length) throw error;
           await waitForStaleRetry(staleRetries++);
@@ -12692,9 +13056,21 @@ var SolanaLLMClient = class {
         }
       }
       if (!response.ok) throw await unpaidApiError(response);
-      return await this.readUnpaidJson(response);
+      return this.withUnpaidCost(await this.readUnpaidJson(response));
     }
   }
+  /**
+   * Cost of a chat response served without a payment: 0 with a wallet (a free
+   * model). With an API key the call is billed to the account, so costUsd stays
+   * undefined (see the dashboard).
+   */
+  withUnpaidCost(served) {
+    if (!this.apiAuth) {
+      served.costUsd = 0;
+      served.settlement = { scheme: "free", quotedUsd: 0 };
+    }
+    return served;
+  }
   /**
    * Read the JSON body of a 2xx served without a payment: the free tier, or
    * with an API key, where this very request was the billed one.
@@ -12711,9 +13087,9 @@ var SolanaLLMClient = class {
    * {@link RetryDisposition}: `"unpaid"` with a wallet; with an API key, see
    * {@link accountErrorDisposition} (the request itself is billed).
    */
-  async sendUnpaid(url, init) {
+  async sendUnpaid(url, init, timeoutMs) {
     try {
-      return await this.fetchWithTimeout(url, init);
+      return await this.fetchWithTimeout(url, init, timeoutMs);
     } catch (error) {
       throw withDisposition(error, this.apiAuth ? accountErrorDisposition(error) : "unpaid");
     }
@@ -12982,7 +13358,7 @@ var SolanaLLMClient = class {
     if (!feePayer) throw new PaymentError("Missing feePayer in 402 extra field");
     const fromAddress = await this.getWalletAddress();
     const secretKey = await solanaKeyToBytes(this.privateKey);
-    const extensions = paymentRequired.extensions;
+    const extensions = withPaymentIdentifier(paymentRequired).extensions;
     const paymentPayload = await createSolanaPaymentPayload(
       secretKey,
       fromAddress,
@@ -13005,7 +13381,7 @@ var SolanaLLMClient = class {
     );
     return { paymentPayload, costUsd: parseFloat(details.amount) / 1e6 };
   }
-  async handlePaymentAndRetry(url, body, paymentRequired, forceFreshBlockhash = false) {
+  async handlePaymentAndRetry(url, json, paymentRequired, forceFreshBlockhash = false, timeoutMs) {
     let signed;
     try {
       signed = await this.signExactPayment(url, paymentRequired, forceFreshBlockhash, `${this.apiUrl}/v1/chat/completions`);
@@ -13022,14 +13398,15 @@ var SolanaLLMClient = class {
           "User-Agent": USER_AGENT,
           "PAYMENT-SIGNATURE": paymentPayload
         },
-        body: JSON.stringify(body)
-      });
+        body: json
+      }, timeoutMs);
     } catch (error) {
       throw withDisposition(error, "paid-or-in-doubt");
     }
     await this.assertPaid(retryResponse);
     this.recordSettlement(costUsd);
-    return this.readPaidJson(retryResponse);
+    const paid = await this.readPaidJson(retryResponse);
+    return withCost(paid, retryResponse, costUsd, "exact");
   }
   async requestWithPaymentRaw(endpoint, body, media = {}) {
     const url = `${this.apiUrl}${endpoint}`;
@@ -13745,6 +14122,7 @@ var AnthropicClient = class {
   BatchPaymentUnresolvedError,
   BlockrunClient,
   BlockrunError,
+  DEFAULT_BATCH_IN_DOUBT,
   DEFAULT_BATCH_RATE_LIMIT,
   EVM_NETWORKS,
   ImageClient,
@@ -13807,6 +14185,7 @@ var AnthropicClient = class {
   loadWallet,
   logCost,
   parsePaymentRequired,
+  readSettlement,
   retryDisposition,
   saveSolanaWallet,
   saveToCache,
@@ -13821,6 +14200,8 @@ var AnthropicClient = class {
   solanaKeyToBytes,
   solanaPublicKey,
   status,
+  toWireSearchParameters,
+  toWireTools,
   validateMaxTokens,
   validateModel,
   validateTemperature,