@blockrun/llm 3.20.1 → 3.22.0

package/dist/index.js

@@ -313,6 +313,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
 import { privateKeyToAccount } from "viem/accounts";
 
@@ -4099,6 +4215,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()];
 }
@@ -4126,7 +4247,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,
@@ -4146,6 +4267,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
   );
@@ -4564,7 +4694,7 @@ function getCostSummary() {
 }
 
 // src/version.ts
-var SDK_VERSION = "3.20.1";
+var SDK_VERSION = "3.22.0";
 var USER_AGENT = `blockrun-ts/${SDK_VERSION}`;
 
 // src/client.ts
@@ -4710,7 +4840,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
       }
     );
   }
@@ -4777,6 +4909,8 @@ var LLMClient = class _LLMClient {
         requiresStructuredOutput: options.responseFormat !== void 0,
         tools: options.tools,
         toolChoice: options.toolChoice,
+        search: options.search,
+        searchParameters: options.searchParameters,
         conversationChars,
         hasVision
       }
@@ -4791,6 +4925,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
     });
@@ -4867,11 +5002,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;
@@ -4882,7 +5017,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];
@@ -4953,19 +5088,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 {
@@ -4982,7 +5117,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;
@@ -5007,9 +5142,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");
     }
@@ -5017,13 +5152,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.
@@ -5031,7 +5175,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);
@@ -5039,7 +5183,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");
     }
@@ -5084,7 +5228,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: {
@@ -5093,7 +5237,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, {
@@ -5104,7 +5248,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) {
@@ -5120,7 +5264,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) {
@@ -5143,7 +5287,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.
@@ -5213,7 +5357,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;
@@ -5611,11 +5755,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,
@@ -9329,11 +9473,11 @@ var WALLET_DIR = path4.join(os3.homedir(), ".blockrun");
 var SOLANA_WALLET_FILE = path4.join(WALLET_DIR, ".solana-session");
 async function createSolanaWallet() {
   const { Keypair } = await loadSolanaWeb3("Solana wallet operations");
-  const bs582 = await import("bs58");
+  const bs583 = await import("bs58");
   const keypair = Keypair.generate();
   return {
     address: keypair.publicKey.toBase58(),
-    privateKey: (bs582.default ?? bs582).encode(keypair.secretKey)
+    privateKey: (bs583.default ?? bs583).encode(keypair.secretKey)
   };
 }
 async function solanaKeyToBytes(privateKey) {
@@ -9371,8 +9515,8 @@ async function solanaKeyToBytes(privateKey) {
     return bytes;
   }
   try {
-    const bs582 = await import("bs58");
-    const bytes = (bs582.default ?? bs582).decode(key);
+    const bs583 = await import("bs58");
+    const bytes = (bs583.default ?? bs583).decode(key);
     if (bytes.length !== 64) {
       throw new Error(`Invalid Solana key length: expected 64 bytes, got ${bytes.length}`);
     }
@@ -9551,15 +9695,56 @@ async function getOrCreateSolanaWallet() {
   return { address, privateKey, isNew: true };
 }
 
+// src/poll-ownership.ts
+import { createPrivateKey, createPublicKey, sign as ed25519Sign } from "crypto";
+import bs58 from "bs58";
+var POLL_AUTH_HEADERS = {
+  wallet: "x-poll-wallet",
+  timestamp: "x-poll-timestamp",
+  signature: "x-poll-signature"
+};
+function pollAuthMessage(kind, jobId, timestampS) {
+  return `blockrun-poll:v1:${kind}:${jobId}:${timestampS}`;
+}
+function pollJobIdFromUrl(pollUrl) {
+  const path7 = new URL(pollUrl, "https://placeholder.invalid").pathname.replace(/\/+$/, "");
+  const segment = path7.slice(path7.lastIndexOf("/") + 1);
+  if (!segment) throw new Error(`poll_url has no job id segment: ${pollUrl}`);
+  return decodeURIComponent(segment);
+}
+var ED25519_PKCS8_PREFIX = Buffer.from("302e020100300506032b657004220420", "hex");
+function signPollOwnership(secretKey, kind, jobId, nowMs = Date.now()) {
+  if (secretKey.length !== 64 && secretKey.length !== 32) {
+    throw new Error(`Solana secret key must be 64 bytes (or a 32-byte seed), got ${secretKey.length}`);
+  }
+  const seed = Buffer.from(secretKey.subarray(0, 32));
+  const privateKey = createPrivateKey({
+    key: Buffer.concat([ED25519_PKCS8_PREFIX, seed]),
+    format: "der",
+    type: "pkcs8"
+  });
+  const jwk = createPublicKey(privateKey).export({ format: "jwk" });
+  if (!jwk.x) throw new Error("Could not derive the Ed25519 public key");
+  const publicKey = Buffer.from(jwk.x, "base64url");
+  const timestampS = Math.floor(nowMs / 1e3);
+  const signature = ed25519Sign(null, Buffer.from(pollAuthMessage(kind, jobId, timestampS), "utf8"), privateKey);
+  return {
+    [POLL_AUTH_HEADERS.wallet]: bs58.encode(publicKey),
+    [POLL_AUTH_HEADERS.timestamp]: String(timestampS),
+    [POLL_AUTH_HEADERS.signature]: bs58.encode(signature)
+  };
+}
+
 // src/solana-batch.ts
 import { AsyncLocalStorage } from "async_hooks";
 import { randomUUID } from "crypto";
 import * as fs6 from "fs";
 import * as path5 from "path";
-import bs58 from "bs58";
+import bs582 from "bs58";
 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;
@@ -10116,7 +10301,7 @@ function decodeChannelAccount(owner, data) {
     return void 0;
   }
   const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-  const key = (offset) => bs58.encode(data.subarray(offset, offset + 32));
+  const key = (offset) => bs582.encode(data.subarray(offset, offset + 32));
   return {
     deposit: view.getBigUint64(CHANNEL.deposit, true),
     settled: view.getBigUint64(CHANNEL.settled, true),
@@ -10236,6 +10421,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_${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;
@@ -10245,9 +10470,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 {
@@ -10255,7 +10477,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;
@@ -10375,13 +10597,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);
@@ -10514,7 +10765,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");
     }
@@ -10526,11 +10777,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: {},
@@ -10899,14 +11155,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
@@ -10970,6 +11231,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) {
@@ -11059,12 +11329,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) {
@@ -11110,7 +11391,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);
@@ -11159,21 +11440,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) {
@@ -11193,9 +11477,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
@@ -11206,10 +11575,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({
@@ -11296,8 +11666,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;
@@ -11311,6 +11681,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
       };
@@ -11335,6 +11706,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",
@@ -11344,12 +11716,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)) {
@@ -11412,7 +11799,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) {
@@ -11443,7 +11838,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 {
@@ -11536,13 +11931,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 };
     }
   }
   /**
@@ -11676,6 +12065,39 @@ var DEFAULT_MAX_TOKENS2 = 1024;
 var DEFAULT_TIMEOUT14 = 6e4;
 var STALE_BLOCKHASH_RETRY_BACKOFFS_MS = [500, 2e3];
 var MAX_PAYMENT_FAILURE_BYTES = 64 * 1024;
+var DEFAULT_VIDEO_MODEL = "xai/grok-imagine-video";
+var DEFAULT_MUSIC_MODEL = "minimax/music-2.5+";
+var DEFAULT_VIDEO_BUDGET_MS = 9e5;
+var DEFAULT_MUSIC_BUDGET_MS = 3e5;
+var VIDEO_POLL_INTERVAL_MS = 5e3;
+var MAX_PAID_POLL_REFUSALS = 4;
+var MAX_RETRY_AFTER_MS2 = 12e4;
+var MEDIA_SUBMIT_TIMEOUT_MS = 12e4;
+function sleep3(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function readJsonOrEmpty(response) {
+  try {
+    const parsed = await response.json();
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function isPendingPollStatus(status2) {
+  return status2 === 202 || status2 === 503 || status2 === 504;
+}
+function retryAfterMs(response) {
+  const raw = response.headers.get("retry-after");
+  if (!raw || !/^\d+$/.test(raw.trim())) return void 0;
+  return Math.min(Number(raw.trim()) * 1e3, MAX_RETRY_AFTER_MS2);
+}
+function pollKindFor(url) {
+  const path7 = new URL(url).pathname;
+  if (path7.includes("/v1/videos")) return "video";
+  if (path7.includes("/v1/audio/")) return "audio";
+  return "image";
+}
 var SafeStaleBlockhashError = class extends PaymentError {
   constructor() {
     super("Payment verification used an expired Solana blockhash; retrying with a fresh quote.");
@@ -11892,9 +12314,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;
@@ -11905,7 +12327,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;
@@ -11955,6 +12377,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
       }
     );
@@ -11982,6 +12406,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
@@ -11997,6 +12423,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
     });
@@ -12134,7 +12561,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 {
@@ -12149,6 +12576,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;
@@ -12156,7 +12586,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;
     }
   }
@@ -12185,6 +12616,54 @@ var SolanaLLMClient = class {
     const data = await this.requestWithPaymentRaw("/v1/images/image2image", body);
     return data;
   }
+  /**
+   * Generate a short video on Solana.
+   *
+   * The POST is verified, not charged. The job is then polled with a wallet
+   * signature (no payment) until it finishes, and ONE payment is signed for
+   * the finished video; a failed job is never charged. If the gateway does not
+   * accept poll signatures for the job, it is polled with a payment per poll
+   * instead, which is likewise only charged on completion.
+   *
+   * @param prompt - text description of the video.
+   * @param options - `model` (default `xai/grok-imagine-video`), `budgetMs`
+   *   (total wait, default 15 min); any other keys are sent verbatim, so use
+   *   the gateway's snake_case names (`duration_seconds`, `image_url`,
+   *   `aspect_ratio`, `resolution`, …).
+   */
+  async video(prompt, options = {}) {
+    const { model, budgetMs, ...rest } = options;
+    const body = { ...rest, model: model || DEFAULT_VIDEO_MODEL, prompt };
+    const data = await this.requestWithPaymentRaw(
+      "/v1/videos/generations",
+      body,
+      { pollBudgetMs: budgetMs ?? DEFAULT_VIDEO_BUDGET_MS, submitTimeoutMs: Math.max(this.timeout, MEDIA_SUBMIT_TIMEOUT_MS) }
+    );
+    return data;
+  }
+  /**
+   * Generate a music track on Solana. Paid at the POST; a slow track is then
+   * polled with a wallet signature, never another payment.
+   *
+   * @param prompt - music style, mood, or description.
+   * @param options - `model` (default `minimax/music-2.5+`), `instrumental`
+   *   (default true), `lyrics` (requires `instrumental: false`), `budgetMs`
+   *   (total wait, default 5 min); other keys are sent verbatim.
+   */
+  async music(prompt, options = {}) {
+    const { model, instrumental: instrumentalOption, lyrics: rawLyrics, budgetMs, ...rest } = options;
+    const instrumental = instrumentalOption ?? true;
+    const lyrics = rawLyrics?.trim();
+    if (instrumental && lyrics) throw new Error("Cannot specify lyrics when instrumental is true");
+    const body = { ...rest, model: model || DEFAULT_MUSIC_MODEL, prompt, instrumental };
+    if (lyrics) body.lyrics = lyrics;
+    const data = await this.requestWithPaymentRaw(
+      "/v1/audio/generations",
+      body,
+      { pollBudgetMs: budgetMs ?? DEFAULT_MUSIC_BUDGET_MS, submitTimeoutMs: Math.max(this.timeout, MEDIA_SUBMIT_TIMEOUT_MS) }
+    );
+    return data;
+  }
   /** Standalone search (Solana payment). */
   async search(query, options) {
     const body = { query, max_results: options?.maxResults || 10 };
@@ -12383,15 +12862,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;
@@ -12407,16 +12887,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) };
@@ -12431,13 +12911,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++);
@@ -12445,8 +12926,20 @@ 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
@@ -12464,9 +12957,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");
     }
@@ -12480,106 +12973,221 @@ var SolanaLLMClient = class {
     }
   }
   /**
-   * Turn a `402` into a signed Solana payment payload.
-   *
-   * Extracted because four call sites need it — chat, the raw POST helpers, the
-   * raw GET helper, and {@link SolanaLLMClient.stream} — and it had been
-   * written out three times before this. That mattered more than ordinary
-   * duplication: this is the code that signs a transfer of the caller's USDC,
-   * so three copies meant every fix to it had to be applied three times or
-   * quietly apply to two thirds of the paths.
-   *
-   * @param url - the request being paid for.
-   * @param response - the gateway's `402`, not yet consumed.
-   * @param forceFreshBlockhash - set on a re-sign after a stale-blockhash
-   *   rejection, so the retry cannot produce byte-identical transaction bytes.
-   * @param resourceFallback - resource URL to claim when the 402 states none.
-   * @returns the header value to replay with, and what it will settle for.
-   * @throws PaymentError when the 402 carries no usable Solana requirements.
-   */
-  /**
-   * Follow a 202 `{ id, poll_url }` to completion, on Solana **image** routes.
-   *
-   * Two things differ from Base and both come from the same constraint — a
-   * Solana payment is a transaction pinned to a recent blockhash, valid for
-   * ~150 blocks (~60s), and a long render outlives it:
-   *
-   * 1. **The POST already settled.** Base settles on the completed poll; Solana
-   *    cannot, because by then the signed transaction has expired. So sol
-   *    settles optimistically at submit, and this loop only fetches the result.
-   *    The cost is recorded by the caller at POST, never here — recording it on
-   *    completion would lose the charge whenever a paid job then fails.
-   *    Solana VIDEO is the exception: it settles on the completed poll and a
-   *    failed job is not charged. Do not route video through this loop as-is —
-   *    it would book spend for jobs that were never charged.
-   * 2. **Every poll re-signs.** One authorization cannot be replayed across a
-   *    long render. The gateway binds the job to the payer address rather than
-   *    to the signature, so a fresh signature from the same wallet is accepted
-   *    and is never charged again.
+   * Follow a 202 `{ id, poll_url }` to completion on a Solana media route
+   * (image, music, video).
+   *
+   * **Polls prove ownership, they do not pay.** A Solana payment is a
+   * transaction pinned to a recent blockhash (~60s), so paying every poll of a
+   * multi-minute job meant signing a fresh transaction every few seconds. Each
+   * poll here instead carries the `x-poll-*` headers: the submitting wallet's
+   * ed25519 signature over `blockrun-poll:v1:<kind>:<job id>:<unix seconds>`
+   * (see `poll-ownership.ts`). That proof never charges.
+   *
+   * **Who pays when:**
+   * - image / music: the POST already settled (sol settles at submit because the
+   *   signed transaction would be dead by completion). The caller recorded the
+   *   cost at POST; this loop only fetches the result and never signs a payment.
+   *   A batch-billed image job still answers its proof poll with 402: that job
+   *   falls back to the per-poll payment below.
+   * - video: settles on completion, and a failed job is never charged. A
+   *   finished, unpaid job answers the proof poll with 402 `{status:"completed"}`
+   *   and a normal x402 challenge; ONE payment is signed from that challenge and
+   *   the same poll is re-sent with it. The cost is recorded here, on delivery.
+   *   A paid poll the gateway answers 402 (settlement in progress on another
+   *   poll, outcome unknown, stale blockhash) is re-polled after its
+   *   Retry-After — the gateway's per-job settlement claim makes a later fresh
+   *   payment safe — up to `MAX_PAID_POLL_REFUSALS` times.
+   *
+   * **Fallback, once per job:** if the gateway refuses the proof with its "no
+   * such job" answer (video 400, image/music 404) or answers it with a plain
+   * payment challenge (a gateway or job that predates poll proofs), the rest of
+   * this job is polled the old way — an x-payment signed per poll, which the
+   * gateway verifies against the job's payer and does not charge until a video
+   * completes. Logged to stderr; never switches back.
    */
-  async followSolanaJob(submitBody, budgetMs, intervalMs = 2e3) {
+  async followSolanaJob(submitBody, budgetMs, kind, intervalMs = kind === "video" ? VIDEO_POLL_INTERVAL_MS : 2e3) {
     const id = submitBody.id;
     const pollPath = submitBody.poll_url;
     if (!id || !pollPath) return submitBody;
-    const pollUrl = pollPath.startsWith("http") ? pollPath : `${this.apiUrl}${pollPath.startsWith("/") ? "" : "/"}${pollPath}`;
+    const pollUrl = this.resolvePollUrl(pollPath);
+    const jobId = pollJobIdFromUrl(pollUrl);
     const deadline = Date.now() + budgetMs;
     let lastStatus = submitBody.status || "queued";
+    let ownershipPolls = true;
+    let waitMs = intervalMs;
+    let paidRefusalsLeft = MAX_PAID_POLL_REFUSALS;
+    let videoCostUsd;
+    let settleAttempted = false;
+    const fallBack = (why) => {
+      ownershipPolls = false;
+      waitMs = 0;
+      console.warn(
+        `[@blockrun/llm] ${kind} job ${id}: ${why}; falling back to x-payment polling for this job`
+      );
+    };
+    const deliver = (data, response) => {
+      if (kind === "video") {
+        if (videoCostUsd !== void 0) this.recordSettlement(videoCostUsd);
+        const txHash = response.headers.get("x-payment-receipt");
+        if (txHash) data.txHash = txHash;
+      }
+      return data;
+    };
+    const failIfFailed = (data, status2) => {
+      if (lastStatus === "failed") {
+        throw new APIError(
+          `Upstream job failed: ${data.error || "unknown"}`,
+          status2,
+          sanitizeErrorResponse(data)
+        );
+      }
+    };
     while (Date.now() < deadline) {
-      await new Promise((r) => setTimeout(r, intervalMs));
-      const challenge = await this.fetchWithTimeout(pollUrl, {
-        method: "GET",
-        headers: { "User-Agent": USER_AGENT }
-      });
-      if (challenge.status === 200) {
-        const done = await challenge.json();
-        return done;
+      if (waitMs > 0) await sleep3(Math.min(waitMs, Math.max(0, deadline - Date.now())));
+      waitMs = intervalMs;
+      let challenge;
+      if (ownershipPolls) {
+        const proof = signPollOwnership(await solanaKeyToBytes(this.privateKey), kind, jobId);
+        const polled = await this.fetchWithTimeout(pollUrl, {
+          method: "GET",
+          headers: { "User-Agent": USER_AGENT, ...proof }
+        });
+        const data2 = await readJsonOrEmpty(polled);
+        if (polled.status === 402) {
+          if (kind === "video" && data2.status === "completed") {
+            lastStatus = "completed";
+            settleAttempted = true;
+            challenge = new Response(JSON.stringify(data2), { status: 402, headers: polled.headers });
+          } else {
+            fallBack(
+              kind === "image" ? "the gateway asks for a payment on this poll (a batch-billed job, or a gateway without poll proofs)" : "the gateway answered the poll proof with a payment challenge (a gateway without poll proofs)"
+            );
+            continue;
+          }
+        } else if (polled.status === (kind === "video" ? 400 : 404)) {
+          fallBack(`the gateway refused the poll proof (HTTP ${polled.status})`);
+          continue;
+        } else {
+          lastStatus = data2.status || lastStatus;
+          failIfFailed(data2, polled.status);
+          if (polled.status === 200 && lastStatus === "completed") return deliver(data2, polled);
+          if (!isPendingPollStatus(polled.status)) {
+            throw new APIError(`Poll failed: ${polled.status}`, polled.status, sanitizeErrorResponse(data2));
+          }
+          waitMs = retryAfterMs(polled) ?? intervalMs;
+          continue;
+        }
       }
-      if (challenge.status !== 402) {
-        let errorBody;
-        try {
-          errorBody = await challenge.json();
-        } catch {
-          errorBody = { error: "Poll failed" };
+      if (!challenge) {
+        const unpaid = await this.fetchWithTimeout(pollUrl, {
+          method: "GET",
+          headers: { "User-Agent": USER_AGENT }
+        });
+        if (unpaid.status === 200) {
+          return deliver(await unpaid.json(), unpaid);
+        }
+        if (unpaid.status !== 402) {
+          let errorBody;
+          try {
+            errorBody = await unpaid.json();
+          } catch {
+            errorBody = { error: "Poll failed" };
+          }
+          throw new APIError(`Poll failed: ${unpaid.status}`, unpaid.status, sanitizeErrorResponse(errorBody));
         }
-        throw new APIError(`Poll failed: ${challenge.status}`, challenge.status, sanitizeErrorResponse(errorBody));
+        challenge = unpaid;
       }
-      const { paymentPayload } = await this.signPaymentFrom402(
+      const { paymentPayload, costUsd } = await this.signPaymentFrom402(
         pollUrl,
         challenge,
         true,
         // always a fresh blockhash; the last one is stale by now
         pollUrl
       );
-      const paid = await this.fetchWithTimeout(pollUrl, {
-        method: "GET",
-        headers: { "User-Agent": USER_AGENT, "PAYMENT-SIGNATURE": paymentPayload }
-      });
-      let data = {};
+      if (kind === "video") videoCostUsd = costUsd;
+      let paid;
       try {
-        data = await paid.json();
-      } catch {
+        paid = await this.fetchWithTimeout(pollUrl, {
+          method: "GET",
+          headers: { "User-Agent": USER_AGENT, "PAYMENT-SIGNATURE": paymentPayload }
+        });
+      } catch (error) {
+        if (kind === "video" && lastStatus === "completed") settleAttempted = true;
+        if (--paidRefusalsLeft <= 0) {
+          throw withDisposition(
+            new PaymentError(
+              `Paid poll failed in transit (${error instanceof Error ? error.message : String(error)}). The payment may have settled: resume the job by polling ${pollUrl} with the same wallet before submitting again.`
+            ),
+            "paid-or-in-doubt"
+          );
+        }
+        continue;
       }
+      const data = await readJsonOrEmpty(paid);
       lastStatus = data.status || lastStatus;
-      if (lastStatus === "failed") {
-        throw new APIError(
-          `Upstream job failed: ${data.error || "unknown"}`,
-          paid.status,
-          sanitizeErrorResponse(data)
-        );
-      }
-      if (paid.status === 200 && lastStatus === "completed") {
-        return data;
+      failIfFailed(data, paid.status);
+      if (paid.status === 200 && lastStatus === "completed") return deliver(data, paid);
+      if (paid.status === 402 && kind === "video") {
+        if (data.error === "Payment verification failed" && !await isSafeStaleBlockhashResponse(new Response(JSON.stringify(data), { status: 402 }))) {
+          throw new PaymentError(
+            `Payment for the finished video was rejected. Check your Solana USDC balance, then resume the job by polling ${pollUrl} with the same wallet.`
+          );
+        }
+        settleAttempted = true;
+        if (--paidRefusalsLeft <= 0) {
+          throw withDisposition(
+            new PaymentError(
+              `Payment for the finished video did not settle after ${MAX_PAID_POLL_REFUSALS} attempts (last: ${data.error || "HTTP 402"}). It may still settle: resume the job by polling ${pollUrl} with the same wallet before submitting again.`
+            ),
+            "paid-or-in-doubt"
+          );
+        }
+        waitMs = retryAfterMs(paid) ?? intervalMs;
+        continue;
       }
-      if (paid.status !== 200 && paid.status !== 202 && paid.status !== 504) {
+      if (!isPendingPollStatus(paid.status) && paid.status !== 200) {
         throw new APIError(`Poll failed: ${paid.status}`, paid.status, sanitizeErrorResponse(data));
       }
+      waitMs = retryAfterMs(paid) ?? intervalMs;
     }
+    const billing = kind === "video" ? settleAttempted ? "A payment for the finished video was sent and may still settle." : "Nothing was charged: a video is charged only when a completed poll is paid." : "The submit was already paid.";
     throw new APIError(
-      `Job did not complete within ${Math.round(budgetMs / 1e3)}s (last status: ${lastStatus}). No payment was taken.`,
+      `Job did not complete within ${Math.round(budgetMs / 1e3)}s (last status: ${lastStatus}). ${billing} Resume by polling the same poll_url with the same wallet before submitting again.`,
       504,
-      { id, last_status: lastStatus }
+      { id, last_status: lastStatus, poll_url: pollUrl }
     );
   }
+  /**
+   * Absolute URL for a job's `poll_url`. The gateway returns `/api/v1/...`;
+   * {@link buildUrl} drops the `/api` that `apiUrl` already ends with. An
+   * absolute poll_url must be on the gateway's own origin: the poll carries a
+   * wallet signature (and, for a finished video, a payment).
+   */
+  resolvePollUrl(pollPath) {
+    if (!/^https?:\/\//i.test(pollPath)) return this.buildUrl(pollPath);
+    if (new URL(pollPath).origin !== new URL(this.apiUrl).origin) {
+      throw new APIError(`poll_url is not on the gateway origin: ${pollPath}`, 502, { poll_url: pollPath });
+    }
+    return pollPath;
+  }
+  /**
+   * Turn a `402` into a signed Solana payment payload.
+   *
+   * Extracted because four call sites need it — chat, the raw POST helpers, the
+   * raw GET helper, and {@link SolanaLLMClient.stream} — and it had been
+   * written out three times before this. That mattered more than ordinary
+   * duplication: this is the code that signs a transfer of the caller's USDC,
+   * so three copies meant every fix to it had to be applied three times or
+   * quietly apply to two thirds of the paths.
+   *
+   * @param url - the request being paid for.
+   * @param response - the gateway's `402`, not yet consumed.
+   * @param forceFreshBlockhash - set on a re-sign after a stale-blockhash
+   *   rejection, so the retry cannot produce byte-identical transaction bytes.
+   * @param resourceFallback - resource URL to claim when the 402 states none.
+   * @returns the header value to replay with, and what it will settle for.
+   * @throws PaymentError when the 402 carries no usable Solana requirements.
+   */
   async signPaymentFrom402(url, response, forceFreshBlockhash, resourceFallback = url) {
     return this.signExactPayment(
       url,
@@ -12620,7 +13228,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,
@@ -12643,7 +13251,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`);
@@ -12660,26 +13268,28 @@ 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) {
+  async requestWithPaymentRaw(endpoint, body, media = {}) {
     const url = `${this.apiUrl}${endpoint}`;
+    const pollBudgetMs = media.pollBudgetMs ?? this.timeout;
     for (let staleRetries = 0; ; ) {
       const response = await this.fetchWithTimeout(url, {
         method: "POST",
         headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT },
         body: JSON.stringify(body)
-      });
+      }, media.submitTimeoutMs);
       if (response.status === 402) {
         try {
-          return await this.handlePaymentAndRetryRaw(url, body, response, staleRetries > 0);
+          return await this.handlePaymentAndRetryRaw(url, body, response, staleRetries > 0, media);
         } catch (error) {
           if (!(error instanceof SafeStaleBlockhashError) || staleRetries >= STALE_BLOCKHASH_RETRY_BACKOFFS_MS.length) throw error;
           await waitForStaleRetry(staleRetries++);
@@ -12695,26 +13305,38 @@ var SolanaLLMClient = class {
         }
         throw new APIError(`API error: ${response.status}`, response.status, sanitizeErrorResponse(errorBody));
       }
-      if (this.apiAuth && endpoint.startsWith("/v1/images/")) return this.apiAuth.poll(response, this.timeout, 2e3);
+      if (this.apiAuth && /^\/v1\/(images|videos|audio)\//.test(endpoint)) {
+        return this.apiAuth.poll(
+          response,
+          pollBudgetMs,
+          endpoint.startsWith("/v1/videos/") ? VIDEO_POLL_INTERVAL_MS : 2e3
+        );
+      }
       return response.json();
     }
   }
-  async handlePaymentAndRetryRaw(url, body, response, forceFreshBlockhash = false) {
+  async handlePaymentAndRetryRaw(url, body, response, forceFreshBlockhash = false, media = {}) {
     const { paymentPayload, costUsd } = await this.signPaymentFrom402(url, response, forceFreshBlockhash);
-    const retryResponse = await this.fetchWithTimeout(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "User-Agent": USER_AGENT,
-        "PAYMENT-SIGNATURE": paymentPayload
-      },
-      body: JSON.stringify(body)
-    });
+    let retryResponse;
+    try {
+      retryResponse = await this.fetchWithTimeout(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": USER_AGENT,
+          "PAYMENT-SIGNATURE": paymentPayload
+        },
+        body: JSON.stringify(body)
+      }, media.submitTimeoutMs);
+    } catch (error) {
+      throw withDisposition(error, "paid-or-in-doubt");
+    }
     await this.assertPaid(retryResponse);
     if (retryResponse.status === 202) {
-      this.recordSettlement(costUsd);
+      const kind = pollKindFor(url);
+      if (kind !== "video") this.recordSettlement(costUsd);
       const submitted = await retryResponse.json();
-      return this.followSolanaJob(submitted, this.timeout);
+      return this.followSolanaJob(submitted, media.pollBudgetMs ?? this.timeout, kind);
     }
     this.recordSettlement(costUsd);
     return retryResponse.json();
@@ -12803,9 +13425,9 @@ var SolanaLLMClient = class {
     this.sessionCalls += 1;
     this.sessionTotalUsd += costUsd;
   }
-  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 {
       return await (this.apiAuth ? this.apiAuth.fetch.bind(this.apiAuth) : fetch)(url, { ...options, signal: controller.signal });
     } finally {
@@ -13369,6 +13991,7 @@ export {
   BatchPaymentUnresolvedError,
   BlockrunClient,
   BlockrunError,
+  DEFAULT_BATCH_IN_DOUBT,
   DEFAULT_BATCH_RATE_LIMIT,
   EVM_NETWORKS,
   ImageClient,
@@ -13432,6 +14055,7 @@ export {
   loadWallet,
   logCost,
   parsePaymentRequired,
+  readSettlement,
   retryDisposition,
   saveSolanaWallet,
   saveToCache,
@@ -13446,6 +14070,8 @@ export {
   solanaKeyToBytes,
   solanaPublicKey,
   status,
+  toWireSearchParameters,
+  toWireTools,
   validateMaxTokens,
   validateModel,
   validateTemperature,