@blockrun/llm 3.17.1 → 3.19.0

package/dist/index.cjs

@@ -284,7 +284,7 @@ var TRANSIENT_RETRIES = 2;
 var TRANSIENT_BACKOFF_MS = 1e3;
 function retryDelay(ms, signal) {
   signal?.throwIfAborted();
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const onAbort = () => {
       clearTimeout(timer);
       signal?.removeEventListener("abort", onAbort);
@@ -292,7 +292,7 @@ function retryDelay(ms, signal) {
     };
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve();
+      resolve2();
     }, ms);
     signal?.addEventListener("abort", onAbort, { once: true });
   });
@@ -328,8 +328,8 @@ var ApiKeyAuth = class {
     this.#key = key;
   }
   /** Resolve gateway poll paths without forwarding credentials to another origin. */
-  resolveUrl(path6) {
-    const url = new URL(path6, this.apiUrl + "/");
+  resolveUrl(path7) {
+    const url = new URL(path7, this.apiUrl + "/");
     if (url.origin !== new URL(this.apiUrl).origin || url.username || url.password) {
       throw new Error("Refusing to send a BlockRun API key to a different origin.");
     }
@@ -395,7 +395,7 @@ var ApiKeyAuth = class {
       if (["failed", "cancelled", "canceled"].includes(String(data.status))) {
         throw new APIError("Account API job failed or was cancelled", 502, sanitizeErrorResponse(data));
       }
-      await new Promise((resolve) => setTimeout(resolve, Math.min(interval, Math.max(0, deadline - Date.now()))));
+      await new Promise((resolve2) => setTimeout(resolve2, Math.min(interval, Math.max(0, deadline - Date.now()))));
       const remaining = deadline - Date.now();
       if (remaining <= 0) break;
       try {
@@ -4660,7 +4660,7 @@ function getCostSummary() {
 }
 
 // src/version.ts
-var SDK_VERSION = "3.17.1";
+var SDK_VERSION = "3.19.0";
 var USER_AGENT = `blockrun-ts/${SDK_VERSION}`;
 
 // src/client.ts
@@ -5769,8 +5769,8 @@ var LLMClient = class _LLMClient {
    * @example
    * const results = await client.exa("search", { query: "latest AI research", numResults: 5 });
    */
-  async exa(path6, body) {
-    return this.requestWithPaymentRaw(`/v1/exa/${path6}`, body);
+  async exa(path7, body) {
+    return this.requestWithPaymentRaw(`/v1/exa/${path7}`, body);
   }
   /**
    * Neural web search via Exa. Returns semantically relevant URLs and metadata.
@@ -5918,8 +5918,8 @@ var LLMClient = class _LLMClient {
    * const market = await client.pm("kalshi/markets/KXBTC-25MAR14");
    * const results = await client.pm("polymarket/search", { q: "bitcoin" });
    */
-  async pm(path6, params) {
-    return this.getWithPaymentRaw(`/v1/pm/${path6}`, params);
+  async pm(path7, params) {
+    return this.getWithPaymentRaw(`/v1/pm/${path7}`, params);
   }
   /**
    * Structured query for Predexon prediction market data (POST endpoints).
@@ -5935,8 +5935,8 @@ var LLMClient = class _LLMClient {
    *   addresses: ["0xabc...", "0xdef..."],
    * });
    */
-  async pmQuery(path6, query) {
-    return this.requestWithPaymentRaw(`/v1/pm/${path6}`, query);
+  async pmQuery(path7, query) {
+    return this.requestWithPaymentRaw(`/v1/pm/${path7}`, query);
   }
   // ── PM convenience helpers (Predexon v2) ─────────────────────────────────
   // Thin wrappers over pm() / pmQuery() for the most common v2 endpoints.
@@ -6024,8 +6024,8 @@ var LLMClient = class _LLMClient {
    *               "prices/coingecko:bitcoin,base:0x..."
    * @param params - Query parameters passed through to DefiLlama
    */
-  async defi(path6, params) {
-    return this.getWithPaymentRaw(`/v1/defillama/${path6}`, params);
+  async defi(path7, params) {
+    return this.getWithPaymentRaw(`/v1/defillama/${path7}`, params);
   }
   /** All DeFi protocols with TVL. */
   async defiProtocols() {
@@ -6061,9 +6061,9 @@ var LLMClient = class _LLMClient {
    * @param params - Query params (chainId, sellToken, buyToken, sellAmount, taker, ...)
    * @param body - JSON body — pass to switch to POST (gasless/submit only)
    */
-  async dex(path6, params, body) {
-    if (body) return this.requestWithPaymentRaw(`/v1/zerox/${path6}`, body);
-    return this.getWithPaymentRaw(`/v1/zerox/${path6}`, params);
+  async dex(path7, params, body) {
+    if (body) return this.requestWithPaymentRaw(`/v1/zerox/${path7}`, body);
+    return this.getWithPaymentRaw(`/v1/zerox/${path7}`, params);
   }
   /** Indicative Permit2 swap price — no commitment (free). */
   async dexPrice(params) {
@@ -6107,8 +6107,8 @@ var LLMClient = class _LLMClient {
    *               "sandbox/status", "sandbox/terminate"
    * @param body - JSON body for the endpoint
    */
-  async modal(path6, body) {
-    return this.requestWithPaymentRaw(`/v1/modal/${path6}`, body ?? {});
+  async modal(path7, body) {
+    return this.requestWithPaymentRaw(`/v1/modal/${path7}`, body ?? {});
   }
   /** Create a sandboxed compute environment (CPU / GPU tiers). */
   async modalSandboxCreate(body) {
@@ -6416,7 +6416,7 @@ var ImageClient = class {
     const pollUrl = pollPath.startsWith("/api/") ? `${this.apiUrl.replace(/\/api$/, "")}${pollPath}` : `${this.apiUrl}${pollPath.startsWith("/") ? "" : "/"}${pollPath}`;
     const startedAt = Date.now();
     while (Date.now() - startedAt < POLL_MAX_DURATION_MS) {
-      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+      await new Promise((resolve2) => setTimeout(resolve2, POLL_INTERVAL_MS));
       const pollResp = await this.fetchWithTimeout(pollUrl, {
         method: "GET",
         headers: {
@@ -6958,8 +6958,36 @@ var VideoClient = class {
           "referenceImageUrls is mutually exclusive with imageUrl, lastFrameUrl, and realFaceAssetId."
         );
       }
-      if (options.referenceImageUrls.length > 9) {
-        throw new Error("referenceImageUrls accepts at most 9 images.");
+      const imageLimit = options.model?.replace(/^bytedance\//, "") === "seedance-2.5" ? 30 : 9;
+      if (options.referenceImageUrls.length > imageLimit) {
+        throw new Error(`referenceImageUrls accepts at most ${imageLimit} images.`);
+      }
+    }
+    for (const [field, clips] of [
+      ["referenceVideos", options?.referenceVideos],
+      ["referenceAudios", options?.referenceAudios]
+    ]) {
+      if (clips === void 0) continue;
+      if (clips.length < 1 || clips.length > 3) {
+        throw new Error(`${field} accepts 1 to 3 clips.`);
+      }
+      for (const clip of clips) {
+        if (typeof clip?.url !== "string" || !/^https?:\/\//i.test(clip.url)) {
+          throw new Error(`${field} URLs must be http(s).`);
+        }
+        if (clip.role !== void 0 && clip.role !== "reference") {
+          throw new Error(`${field} role must be "reference" (or omitted).`);
+        }
+      }
+    }
+    if (options?.referenceVideos?.length || options?.referenceAudios?.length) {
+      if (options.imageUrl || options.lastFrameUrl || options.realFaceAssetId) {
+        throw new Error(
+          "referenceVideos / referenceAudios are mutually exclusive with imageUrl, lastFrameUrl, and realFaceAssetId; combine them with referenceImageUrls instead."
+        );
+      }
+      if (options.referenceAudios?.length && !options.referenceImageUrls?.length && !options.referenceVideos?.length) {
+        throw new Error("referenceAudios requires referenceImageUrls or referenceVideos.");
       }
     }
     const body = {
@@ -6976,7 +7004,14 @@ var VideoClient = class {
     if (options?.generateAudio !== void 0) body.generate_audio = options.generateAudio;
     if (options?.seed !== void 0) body.seed = options.seed;
     if (options?.watermark !== void 0) body.watermark = options.watermark;
-    if (options?.returnLastFrame) body.return_last_frame = true;
+    if (options?.returnLastFrame !== void 0) body.return_last_frame = options.returnLastFrame;
+    if (options?.referenceVideos !== void 0) body.reference_videos = options.referenceVideos;
+    if (options?.referenceAudios !== void 0) body.reference_audios = options.referenceAudios;
+    if (options?.bitrateMode !== void 0) body.bitrate_mode = options.bitrateMode;
+    if (options?.outputFormat !== void 0) body.output_format = options.outputFormat;
+    if (options?.cameraFixed !== void 0) body.camera_fixed = options.cameraFixed;
+    if (options?.safetyIdentifier !== void 0) body.safety_identifier = options.safetyIdentifier;
+    if (options?.inputType !== void 0) body.input_type = options.inputType;
     const budgetMs = options?.budgetMs ?? DEFAULT_GENERATE_BUDGET_MS;
     return this.submitAndPoll(body, budgetMs);
   }
@@ -6984,8 +7019,11 @@ var VideoClient = class {
    * Generate a video from a standard Seedance `content[]` body.
    *
    * Targets the gateway's `POST /v1/videos` endpoint, which accepts the
-   * mainstream multimodal `content` array (text + a single reference image)
-   * used by other Seedance APIs — so callers already holding a
+   * mainstream multimodal `content` array used by other Seedance APIs. Items
+   * may carry a `role` — `first_frame`, `last_frame`, `reference_image`,
+   * `reference_video`, `reference_audio` — which the gateway maps to the same
+   * validated fields as {@link generate}; a role-less single image keeps its
+   * first-frame meaning — so callers already holding a
    * `content[]`-shaped request can submit it unchanged. The gateway validates
    * unsupported inputs *before* charging, then delegates to the same x402
    * submit+poll pipeline as {@link generate}.
@@ -6999,7 +7037,8 @@ var VideoClient = class {
    *   `{ type: "image_url", image_url: { url: "https://..." } }`.
    * @param options - `model`, `budgetMs`, plus the same camelCase render options
    *   as {@link generate} (`durationSeconds`, `aspectRatio`, `resolution`,
-   *   `generateAudio`, `seed`, `watermark`, `returnLastFrame`). These are mapped
+   *   `generateAudio`, `seed`, `watermark`, `returnLastFrame`, `bitrateMode`,
+   *   `outputFormat`, `cameraFixed`, `safetyIdentifier`, `inputType`). These are mapped
    *   to the gateway's snake_case fields for you. Any other keys you pass are
    *   forwarded verbatim (use snake_case for those, since the gateway reads
    *   snake_case only).
@@ -7018,6 +7057,11 @@ var VideoClient = class {
       seed,
       watermark,
       returnLastFrame,
+      bitrateMode,
+      outputFormat,
+      cameraFixed,
+      safetyIdentifier,
+      inputType,
       ...extra
     } = options ?? {};
     const body = { ...extra, content };
@@ -7029,6 +7073,11 @@ var VideoClient = class {
     if (seed !== void 0) body.seed = seed;
     if (watermark !== void 0) body.watermark = watermark;
     if (returnLastFrame !== void 0) body.return_last_frame = returnLastFrame;
+    if (bitrateMode !== void 0) body.bitrate_mode = bitrateMode;
+    if (outputFormat !== void 0) body.output_format = outputFormat;
+    if (cameraFixed !== void 0) body.camera_fixed = cameraFixed;
+    if (safetyIdentifier !== void 0) body.safety_identifier = safetyIdentifier;
+    if (inputType !== void 0) body.input_type = inputType;
     return this.submitAndPoll(body, budgetMs ?? DEFAULT_GENERATE_BUDGET_MS, "/v1/videos");
   }
   // --------------------------------------------------------------------
@@ -7565,8 +7614,8 @@ var PhoneClient = class {
     return data;
   }
   // ─── Internals ─────────────────────────────────────────────────────────
-  async request(path6, body) {
-    const url = `${this.apiUrl}/v1/phone/${path6}`;
+  async request(path7, body) {
+    const url = `${this.apiUrl}/v1/phone/${path7}`;
     const response = await this.fetchWithTimeout(url, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -8007,10 +8056,10 @@ var PriceClient = class {
   }
   async price(category, symbol, options) {
     if (!symbol) throw new Error("symbol is required");
-    const path6 = categoryPath(category, options?.market, "price", symbol);
+    const path7 = categoryPath(category, options?.market, "price", symbol);
     const query = {};
     if (options?.session) query.session = options.session;
-    const data = await this.getWithPayment(path6, query);
+    const data = await this.getWithPayment(path7, query);
     return {
       symbol: data.symbol ?? symbol.toUpperCase(),
       price: data.price,
@@ -8029,14 +8078,14 @@ var PriceClient = class {
     if (!options.from || options.from <= 0) {
       throw new Error("history requires options.from (unix seconds)");
     }
-    const path6 = categoryPath(category, options.market, "history", symbol);
+    const path7 = categoryPath(category, options.market, "history", symbol);
     const query = {
       resolution: options.resolution ?? "D",
       from: String(options.from)
     };
     if (options.to) query.to = String(options.to);
     if (options.session) query.session = options.session;
-    const data = await this.getWithPayment(path6, query);
+    const data = await this.getWithPayment(path7, query);
     return {
       symbol: data.symbol ?? symbol.toUpperCase(),
       resolution: data.resolution ?? (options.resolution ?? "D"),
@@ -8048,12 +8097,12 @@ var PriceClient = class {
     };
   }
   async listSymbols(category, options) {
-    const path6 = categoryPath(category, options?.market, "list");
+    const path7 = categoryPath(category, options?.market, "list");
     const query = {
       limit: String(options?.limit && options.limit > 0 ? options.limit : 100)
     };
     if (options?.query) query.q = options.query;
-    const data = await this.getWithPayment(path6, query);
+    const data = await this.getWithPayment(path7, query);
     if (Array.isArray(data)) {
       return { symbols: data, count: data.length };
     }
@@ -8226,19 +8275,19 @@ var SurfClient = class {
    * `/v1/surf` is tolerated and stripped). Query params are URL-encoded;
    * arrays become repeated keys (`?a=1&a=2`).
    */
-  async get(path6, params) {
-    const url = this.buildUrl(path6, params);
+  async get(path7, params) {
+    const url = this.buildUrl(path7, params);
     return this.requestWithPayment(url, "GET");
   }
   /**
    * POST a Surf endpoint with a JSON body. Same path normalization as `get`.
    */
-  async post(path6, body) {
-    const url = this.buildUrl(path6);
+  async post(path7, body) {
+    const url = this.buildUrl(path7);
     return this.requestWithPayment(url, "POST", body);
   }
-  buildUrl(path6, params) {
-    let normalized = path6.startsWith("/") ? path6 : `/${path6}`;
+  buildUrl(path7, params) {
+    let normalized = path7.startsWith("/") ? path7 : `/${path7}`;
     if (!normalized.startsWith(SURF_PREFIX)) {
       normalized = `${SURF_PREFIX}${normalized}`;
     }
@@ -8696,15 +8745,15 @@ var BlockrunClient = class {
    * `/api` is tolerated and stripped). Query params are URL-encoded; arrays
    * become repeated keys (`?a=1&a=2`); undefined/null are dropped.
    */
-  async get(path6, params) {
-    const url = this.buildUrl(path6, params);
+  async get(path7, params) {
+    const url = this.buildUrl(path7, params);
     return this.requestWithPayment(url, "GET");
   }
   /**
    * POST a BlockRun endpoint with a JSON body.
    */
-  async post(path6, body) {
-    const url = this.buildUrl(path6);
+  async post(path7, body) {
+    const url = this.buildUrl(path7);
     return this.requestWithPayment(url, "POST", body);
   }
   /**
@@ -8728,8 +8777,8 @@ var BlockrunClient = class {
    * short-circuits and returns the body. Most long-running endpoints (image,
    * video, music, voice) return 202 with a poll_url.
    */
-  async poll(path6, body, options) {
-    const submitUrl = this.buildUrl(path6);
+  async poll(path7, body, options) {
+    const submitUrl = this.buildUrl(path7);
     const budgetMs = options?.budgetMs ?? DEFAULT_POLL_BUDGET_MS;
     const intervalMs = options?.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
     const resp402 = await this.fetchWithTimeout(submitUrl, {
@@ -8829,8 +8878,8 @@ var BlockrunClient = class {
    *     process.stdout.write(chunk.choices?.[0]?.delta?.content ?? "");
    *   }
    */
-  async *stream(path6, body) {
-    const url = this.buildUrl(path6);
+  async *stream(path7, body) {
+    const url = this.buildUrl(path7);
     const requestBody = JSON.stringify(body ?? {});
     const resp402 = await this.fetchWithTimeout(url, {
       method: "POST",
@@ -8873,8 +8922,8 @@ var BlockrunClient = class {
   // --------------------------------------------------------------------
   // Internal: shared infrastructure
   // --------------------------------------------------------------------
-  buildUrl(path6, params) {
-    let normalized = path6.startsWith("/") ? path6 : `/${path6}`;
+  buildUrl(path7, params) {
+    let normalized = path7.startsWith("/") ? path7 : `/${path7}`;
     if (normalized.startsWith("/api/")) {
       normalized = normalized.slice(4);
     }
@@ -9520,6 +9569,332 @@ async function getOrCreateSolanaWallet() {
   return { address, privateKey, isNew: true };
 }
 
+// src/solana-batch.ts
+var fs6 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+var BATCH_SCHEME = "batch-settlement";
+var INSTALL_HINT2 = "npm install @x402/core@~2.28.0 @x402/svm@~2.28.0 @solana/kit";
+async function load(pkg, importer) {
+  try {
+    return await importer();
+  } catch (err) {
+    throw new Error(
+      `@blockrun/llm: Solana batch-settlement requires the optional peer dependency "${pkg}", which is not installed.
+
+  ${INSTALL_HINT2}
+
+Original error: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+}
+var FileChannelStorage = class {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  read() {
+    try {
+      const parsed = JSON.parse(fs6.readFileSync(this.file, "utf8"));
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch (err) {
+      if (err.code === "ENOENT") return {};
+      throw err;
+    }
+  }
+  write(all) {
+    fs6.mkdirSync(path5.dirname(this.file), { recursive: true, mode: 448 });
+    const tmp = `${this.file}.${process.pid}.tmp`;
+    fs6.writeFileSync(tmp, JSON.stringify(all, null, 2), { mode: 384 });
+    fs6.renameSync(tmp, this.file);
+  }
+  async get(key) {
+    return this.read()[key];
+  }
+  async set(key, record) {
+    const all = this.read();
+    all[key] = record;
+    this.write(all);
+  }
+  async delete(key) {
+    const all = this.read();
+    if (!(key in all)) return;
+    delete all[key];
+    this.write(all);
+  }
+  /** Forget every channel in this file. */
+  clear() {
+    try {
+      fs6.unlinkSync(this.file);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+};
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+var heldLocks = /* @__PURE__ */ new Set();
+var exitHookInstalled = false;
+function lockChannelFile(file) {
+  if (heldLocks.has(file)) return void 0;
+  const lock = `${file}.lock`;
+  fs6.mkdirSync(path5.dirname(lock), { recursive: true, mode: 448 });
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      fs6.writeFileSync(lock, String(process.pid), { flag: "wx", mode: 384 });
+      heldLocks.add(file);
+      if (!exitHookInstalled) {
+        exitHookInstalled = true;
+        process.once("exit", () => {
+          for (const held of heldLocks) {
+            try {
+              fs6.unlinkSync(`${held}.lock`);
+            } catch {
+            }
+          }
+        });
+      }
+      return void 0;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+    const owner = Number(fs6.readFileSync(lock, "utf8").trim());
+    if (Number.isInteger(owner) && owner > 0 && owner !== process.pid && processAlive(owner)) return owner;
+    try {
+      fs6.unlinkSync(lock);
+    } catch {
+    }
+  }
+  return -1;
+}
+function pendingDeposit(pending) {
+  const entries = Array.isArray(pending) ? pending : [pending];
+  return entries.some(
+    (entry) => entry?.payment?.payload?.type === "deposit"
+  );
+}
+function dropOrphanedPending(storage) {
+  return {
+    get: async (key) => {
+      const record = await storage.get(key);
+      if (!record?.pending || record.channelConfig?.voucherSigner !== "server") return record;
+      if (!record.hasConfirmedState || pendingDeposit(record.pending)) {
+        await storage.delete(key);
+        return void 0;
+      }
+      const { pending: _pending, hasConfirmedState: _confirmed, ...confirmed } = record;
+      await storage.set(key, confirmed);
+      return confirmed;
+    },
+    set: (key, record) => storage.set(key, record),
+    delete: (key) => storage.delete(key)
+  };
+}
+function offersBatch(paymentRequired) {
+  return (paymentRequired.accepts ?? []).some((accept) => accept.scheme === BATCH_SCHEME);
+}
+function atomicToUsd(amount) {
+  return amount !== void 0 && /^\d+$/.test(amount) ? Number(amount) / 1e6 : void 0;
+}
+async function isBatchRefusal(response) {
+  if (response.status === 402) return "payment_required";
+  if (![400, 403, 409, 503].includes(response.status)) return void 0;
+  let body;
+  try {
+    body = await response.clone().json();
+  } catch {
+    return void 0;
+  }
+  const { error, code } = body ?? {};
+  if (code === "PAYMENT_VERIFICATION_UNAVAILABLE") return code;
+  return typeof error === "string" && error.startsWith("batch_") ? error : void 0;
+}
+var wallets = /* @__PURE__ */ new Map();
+var SolanaBatchPayer = class {
+  constructor(init) {
+    this.init = init;
+    const { operators } = 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");
+    }
+  }
+  init;
+  state;
+  async storeFile() {
+    const { channelStore } = this.init.options;
+    if (channelStore === false) return void 0;
+    return path5.resolve(channelStore ?? path5.join(paths().dir, "solana-batch", `${await this.init.address()}.json`));
+  }
+  /**
+   * This wallet's shared batch state, or why this client cannot use batch:
+   * another client in this process holds the wallet with a different trust
+   * configuration, or another live process owns its channel file.
+   */
+  wallet() {
+    this.state ??= (async () => {
+      const address = await this.init.address();
+      const file = await this.storeFile();
+      const { operators, maxDeposit } = this.init.options;
+      const config = JSON.stringify([[...operators].sort(), String(maxDeposit ?? ""), file ?? null, this.init.rpcUrl]);
+      const existing = wallets.get(address);
+      if (existing) {
+        return existing.config === config ? existing : "another client in this process uses this wallet with different batch options";
+      }
+      if (file) {
+        const owner = lockChannelFile(file);
+        if (owner !== void 0) return `channel store ${file} is in use by process ${owner}`;
+      }
+      const created = { config, busy: false, warned: /* @__PURE__ */ new Set() };
+      wallets.set(address, created);
+      return created;
+    })();
+    return this.state;
+  }
+  build(wallet) {
+    wallet.client ??= (async () => {
+      const [core, svm, kit] = await Promise.all([
+        load("@x402/core", () => import("@x402/core/client")),
+        load("@x402/svm", () => import("@x402/svm/batch-settlement/client")),
+        load("@solana/kit", () => import("@solana/kit"))
+      ]);
+      const signer = await kit.createKeyPairSignerFromBytes(await this.init.secretKey());
+      const file = await this.storeFile();
+      const storage = file ? dropOrphanedPending(new FileChannelStorage(file)) : void 0;
+      const scheme = new svm.BatchSvmScheme(signer, {
+        rpcUrl: this.init.rpcUrl,
+        serverSignedChannelsPolicy: {
+          allowedOperators: this.init.options.operators,
+          maxDeposit: this.init.options.maxDeposit ?? svm.DEFAULT_SERVER_SIGNED_MAX_DEPOSIT
+        },
+        ...storage ? { channelStorage: storage } : {}
+      });
+      const client = new core.x402Client().register("solana:*", scheme).registerPolicy(scheme.paymentPolicy);
+      client.setSpendControls({ maxAmountPerPayment: false });
+      return {
+        http: new core.x402HTTPClient(client),
+        refund: (url) => scheme.refund(url)
+      };
+    })();
+    wallet.client.catch(() => {
+      wallet.client = void 0;
+    });
+    return wallet.client;
+  }
+  /**
+   * Drop everything this wallet knows about its channel, on disk and in
+   * memory. The next call rebuilds the scheme, which reads the channel's real
+   * state (deposit, open or closed) from the chain.
+   */
+  async forget(wallet) {
+    wallet.client = void 0;
+    const file = await this.storeFile();
+    if (file) new FileChannelStorage(file).clear();
+  }
+  warn(wallet, reason) {
+    if (wallet?.warned.has(reason)) return;
+    wallet?.warned.add(reason);
+    console.error(`[@blockrun/llm] batch-settlement unavailable (${reason}); paying with exact`);
+  }
+  /**
+   * Pay one 402 with batch-settlement, or say why the caller should use exact.
+   *
+   * `send` replays the original request with the payment headers. The
+   * returned response is 2xx; any other answer either becomes a fallback (the
+   * gateway charged nothing) or is returned to the caller's own error path.
+   */
+  async pay(paymentRequired, send) {
+    if (!offersBatch(paymentRequired)) return { kind: "fallback", reason: "not_offered" };
+    const wallet = await this.wallet();
+    if (typeof wallet === "string") {
+      this.warn(void 0, wallet);
+      return { kind: "fallback", reason: wallet };
+    }
+    if (wallet.busy) return { kind: "fallback", reason: "channel_busy" };
+    wallet.busy = true;
+    try {
+      let http;
+      let payload;
+      try {
+        http = (await this.build(wallet)).http;
+        payload = await http.createPaymentPayload(paymentRequired);
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        this.warn(wallet, reason);
+        return { kind: "fallback", reason };
+      }
+      const deposit = payload.payload?.type === "deposit";
+      let response;
+      try {
+        response = await send(http.encodePaymentSignatureHeader(payload));
+      } catch (err) {
+        if (deposit) await this.forget(wallet);
+        else await this.settle(http, payload, () => null, 0);
+        throw err;
+      }
+      const getHeader = (name) => response.headers.get(name);
+      const settled = await this.settle(http, payload, getHeader, response.status);
+      if (deposit && !(response.ok && settled?.success === true)) await this.forget(wallet);
+      if (response.ok) {
+        const charged = atomicToUsd(settled?.amount) ?? atomicToUsd(payload.accepted?.amount) ?? 0;
+        return { kind: "paid", response, chargedUsd: charged };
+      }
+      const refusal = await isBatchRefusal(response);
+      if (refusal) {
+        this.warn(wallet, refusal);
+        return { kind: "fallback", reason: refusal };
+      }
+      return { kind: "failed", response };
+    } finally {
+      wallet.busy = false;
+    }
+  }
+  /**
+   * Hand the gateway's answer to the scheme, which verifies the operator's
+   * voucher and advances (or rolls back) the channel's local state.
+   *
+   * A malformed receipt must not lose a response the caller has been served,
+   * so a scheme error is logged rather than thrown.
+   */
+  async settle(http, payload, getHeader, status2) {
+    try {
+      return (await http.processPaymentResult(payload, getHeader, status2)).settleResponse;
+    } catch (err) {
+      console.error(
+        `[@blockrun/llm] batch-settlement receipt not reconciled: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return void 0;
+    }
+  }
+  /**
+   * Close the channel and return its unused escrow to the wallet.
+   *
+   * The scheme keeps a closed channel in its records, and would go on paying
+   * into it, so a successful close forgets the channel. The next batch call
+   * finds no open channel on-chain and opens a new one.
+   *
+   * @param url - any batch-enabled route on the gateway the channel was opened with.
+   */
+  async close(url) {
+    const wallet = await this.wallet();
+    if (typeof wallet === "string") throw new Error(`batch-settlement unavailable: ${wallet}`);
+    if (wallet.busy) throw new Error("batch-settlement channel has a request in flight; close it when the call returns");
+    wallet.busy = true;
+    try {
+      const result = await (await this.build(wallet)).refund(url);
+      await this.forget(wallet);
+      return result;
+    } finally {
+      wallet.busy = false;
+    }
+  }
+};
+
 // src/solana-client.ts
 var SOLANA_API_URL = "https://sol.blockrun.ai/api";
 var DEFAULT_MAX_TOKENS2 = 1024;
@@ -9583,7 +9958,7 @@ async function isSafeStaleBlockhashResponse(response) {
 }
 async function waitForStaleRetry(attempt) {
   await new Promise(
-    (resolve) => setTimeout(resolve, STALE_BLOCKHASH_RETRY_BACKOFFS_MS[attempt])
+    (resolve2) => setTimeout(resolve2, STALE_BLOCKHASH_RETRY_BACKOFFS_MS[attempt])
   );
 }
 var DEFAULT_SOLANA_RPC_URL = "https://sol.blockrun.ai/api/v1/solana/rpc";
@@ -9627,6 +10002,7 @@ var SolanaLLMClient = class {
   addressCache = null;
   modelPricingCache = null;
   modelPricingPromise = null;
+  batchPayer;
   constructor(options = {}) {
     this.apiAuth = resolveApiKeyAuth(options);
     if (!this.apiAuth) {
@@ -9646,6 +10022,25 @@ var SolanaLLMClient = class {
     this.rpcUrl = rpc.url;
     this.rpcHeaders = rpc.headers;
     this.timeout = options.timeout || DEFAULT_TIMEOUT14;
+    if (options.batch && !this.apiAuth) {
+      this.batchPayer = new SolanaBatchPayer({
+        options: options.batch,
+        secretKey: () => solanaKeyToBytes(this.privateKey),
+        address: () => this.getWalletAddress(),
+        rpcUrl: this.rpcUrl
+      });
+    }
+  }
+  /**
+   * Close this wallet's batch-settlement channel and return its unused escrow.
+   *
+   * The gateway closes it cooperatively when it can; otherwise this starts a
+   * payer-forced close and the escrow comes back after the channel's grace
+   * period. Only meaningful with the `batch` option.
+   */
+  async closeBatchChannel() {
+    if (!this.batchPayer) throw new Error("closeBatchChannel() requires the `batch` option in wallet mode");
+    return this.batchPayer.close(`${this.apiUrl}/v1/chat/completions`);
   }
   /** Get Solana wallet address (public key in base58). */
   async getWalletAddress() {
@@ -9839,8 +10234,8 @@ var SolanaLLMClient = class {
    *   how you end up debugging a request you did not send.
    * @returns each decoded SSE frame, in order.
    */
-  async *stream(path6, body) {
-    const url = this.buildUrl(path6);
+  async *stream(path7, body) {
+    const url = this.buildUrl(path7);
     const response = await this.openPaidStream(url, JSON.stringify(body ?? {}));
     yield* readSseFrames(
       response,
@@ -9912,8 +10307,8 @@ var SolanaLLMClient = class {
    * @param path - endpoint path, with or without a leading slash.
    * @returns the absolute URL to call.
    */
-  buildUrl(path6) {
-    let normalized = path6.startsWith("/") ? path6 : `/${path6}`;
+  buildUrl(path7) {
+    let normalized = path7.startsWith("/") ? path7 : `/${path7}`;
     if (normalized.startsWith("/api/")) normalized = normalized.slice(4);
     return `${this.apiUrl}${normalized}`;
   }
@@ -9992,11 +10387,11 @@ var SolanaLLMClient = class {
     return data;
   }
   // ── Prediction Markets (Powered by Predexon) ────────────────────────────
-  async pm(path6, params) {
-    return this.getWithPaymentRaw(`/v1/pm/${path6}`, params);
+  async pm(path7, params) {
+    return this.getWithPaymentRaw(`/v1/pm/${path7}`, params);
   }
-  async pmQuery(path6, query) {
-    return this.requestWithPaymentRaw(`/v1/pm/${path6}`, query);
+  async pmQuery(path7, query) {
+    return this.requestWithPaymentRaw(`/v1/pm/${path7}`, query);
   }
   // ── Exa Web Search (Powered by Exa) ──────────────────────────────────────
   /**
@@ -10008,8 +10403,8 @@ var SolanaLLMClient = class {
    * @example
    * const results = await client.exa("search", { query: "latest AI research", numResults: 5 });
    */
-  async exa(path6, body) {
-    return this.requestWithPaymentRaw(`/v1/exa/${path6}`, body);
+  async exa(path7, body) {
+    return this.requestWithPaymentRaw(`/v1/exa/${path7}`, body);
   }
   /**
    * Neural and keyword web search via Exa (Solana payment).
@@ -10059,8 +10454,8 @@ var SolanaLLMClient = class {
    *               "prices/coingecko:bitcoin,base:0x..."
    * @param params - Query parameters passed through to DefiLlama
    */
-  async defi(path6, params) {
-    return this.getWithPaymentRaw(`/v1/defillama/${path6}`, params);
+  async defi(path7, params) {
+    return this.getWithPaymentRaw(`/v1/defillama/${path7}`, params);
   }
   /** All DeFi protocols with TVL. */
   async defiProtocols() {
@@ -10096,9 +10491,9 @@ var SolanaLLMClient = class {
    * @param params - Query params (chainId, sellToken, buyToken, sellAmount, taker, ...)
    * @param body - JSON body — pass to switch to POST (gasless/submit only)
    */
-  async dex(path6, params, body) {
-    if (body) return this.requestWithPaymentRaw(`/v1/zerox/${path6}`, body);
-    return this.getWithPaymentRaw(`/v1/zerox/${path6}`, params);
+  async dex(path7, params, body) {
+    if (body) return this.requestWithPaymentRaw(`/v1/zerox/${path7}`, body);
+    return this.getWithPaymentRaw(`/v1/zerox/${path7}`, params);
   }
   /** Indicative Permit2 swap price — no commitment (free). */
   async dexPrice(params) {
@@ -10142,8 +10537,8 @@ var SolanaLLMClient = class {
    *               "sandbox/status", "sandbox/terminate"
    * @param body - JSON body for the endpoint
    */
-  async modal(path6, body) {
-    return this.requestWithPaymentRaw(`/v1/modal/${path6}`, body ?? {});
+  async modal(path7, body) {
+    return this.requestWithPaymentRaw(`/v1/modal/${path7}`, body ?? {});
   }
   /** Create a sandboxed compute environment (CPU / GPU tiers). */
   async modalSandboxCreate(body) {
@@ -10180,7 +10575,31 @@ var SolanaLLMClient = class {
       });
       if (response.status === 402) {
         try {
-          return await this.handlePaymentAndRetry(url, body, response, staleRetries > 0);
+          const paymentRequired = await this.readPaymentRequired(response);
+          if (this.batchPayer && staleRetries === 0) {
+            const batch = await this.batchPayer.pay(
+              paymentRequired,
+              (paymentHeaders) => this.fetchWithTimeout(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT, ...paymentHeaders },
+                body: JSON.stringify(body)
+              })
+            );
+            if (batch.kind === "paid") {
+              this.recordSettlement(batch.chargedUsd);
+              return batch.response.json();
+            }
+            if (batch.kind === "failed") {
+              let errorBody;
+              try {
+                errorBody = await batch.response.json();
+              } catch {
+                errorBody = { error: "Request failed" };
+              }
+              throw new APIError(`API error after payment: ${batch.response.status}`, batch.response.status, sanitizeErrorResponse(errorBody));
+            }
+          }
+          return await this.handlePaymentAndRetry(url, body, paymentRequired, staleRetries > 0);
         } catch (error) {
           if (!(error instanceof SafeStaleBlockhashError) || staleRetries >= STALE_BLOCKHASH_RETRY_BACKOFFS_MS.length) throw error;
           await waitForStaleRetry(staleRetries++);
@@ -10218,7 +10637,7 @@ var SolanaLLMClient = class {
    * @throws PaymentError when the 402 carries no usable Solana requirements.
    */
   /**
-   * Follow a 202 `{ id, poll_url }` to completion, on Solana.
+   * 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
@@ -10229,6 +10648,9 @@ var SolanaLLMClient = class {
    *    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
@@ -10298,6 +10720,15 @@ var SolanaLLMClient = class {
     );
   }
   async signPaymentFrom402(url, response, forceFreshBlockhash, resourceFallback = url) {
+    return this.signExactPayment(
+      url,
+      await this.readPaymentRequired(response),
+      forceFreshBlockhash,
+      resourceFallback
+    );
+  }
+  /** Read a `402`'s payment requirements from its header, or its JSON body. */
+  async readPaymentRequired(response) {
     let paymentHeader = response.headers.get("payment-required");
     if (!paymentHeader) {
       try {
@@ -10311,8 +10742,14 @@ var SolanaLLMClient = class {
     if (!paymentHeader) {
       throw new PaymentError("402 response but no payment requirements found");
     }
-    const paymentRequired = parsePaymentRequired(paymentHeader);
-    const details = extractPaymentDetails(paymentRequired, SOLANA_NETWORK);
+    return parsePaymentRequired(paymentHeader);
+  }
+  /** Sign the `exact` accept of a 402 as an SPL TransferChecked payment. */
+  async signExactPayment(url, paymentRequired, forceFreshBlockhash, resourceFallback = url) {
+    const details = extractPaymentDetails(
+      { ...paymentRequired, accepts: paymentRequired.accepts.filter((accept) => accept.scheme !== BATCH_SCHEME) },
+      SOLANA_NETWORK
+    );
     if (!details.network?.startsWith("solana:")) {
       throw new PaymentError(
         `Expected Solana payment network, got: ${details.network}. Use LLMClient for Base payments.`
@@ -10345,10 +10782,10 @@ var SolanaLLMClient = class {
     );
     return { paymentPayload, costUsd: parseFloat(details.amount) / 1e6 };
   }
-  async handlePaymentAndRetry(url, body, response, forceFreshBlockhash = false) {
-    const { paymentPayload, costUsd } = await this.signPaymentFrom402(
+  async handlePaymentAndRetry(url, body, paymentRequired, forceFreshBlockhash = false) {
+    const { paymentPayload, costUsd } = await this.signExactPayment(
       url,
-      response,
+      paymentRequired,
       forceFreshBlockhash,
       `${this.apiUrl}/v1/chat/completions`
     );
@@ -10509,13 +10946,13 @@ function solanaClient(options = {}) {
 }
 
 // src/cache.ts
-var fs6 = __toESM(require("fs"), 1);
-var path5 = __toESM(require("path"), 1);
+var fs7 = __toESM(require("fs"), 1);
+var path6 = __toESM(require("path"), 1);
 var os4 = __toESM(require("os"), 1);
 var crypto2 = __toESM(require("crypto"), 1);
-var CACHE_DIR = path5.join(os4.homedir(), ".blockrun", "cache");
-var DATA_DIR = path5.join(os4.homedir(), ".blockrun", "data");
-var COST_LOG_FILE2 = path5.join(os4.homedir(), ".blockrun", "cost_log.jsonl");
+var CACHE_DIR = path6.join(os4.homedir(), ".blockrun", "cache");
+var DATA_DIR = path6.join(os4.homedir(), ".blockrun", "data");
+var COST_LOG_FILE2 = path6.join(os4.homedir(), ".blockrun", "cost_log.jsonl");
 var DEFAULT_TTL = {
   "/v1/partner/": 3600 * 1e3,
   "/v1/pm/": 1800 * 1e3,
@@ -10535,19 +10972,19 @@ function cacheKey(endpoint, body) {
   return crypto2.createHash("sha256").update(keyData).digest("hex").slice(0, 16);
 }
 function cachePath(key) {
-  return path5.join(CACHE_DIR, `${key}.json`);
+  return path6.join(CACHE_DIR, `${key}.json`);
 }
 function getCached(key) {
   const filePath = cachePath(key);
-  if (!fs6.existsSync(filePath)) return null;
+  if (!fs7.existsSync(filePath)) return null;
   try {
-    const raw = fs6.readFileSync(filePath, "utf-8");
+    const raw = fs7.readFileSync(filePath, "utf-8");
     const entry = JSON.parse(raw);
     const ttl = entry.ttlMs ?? getTtl(entry.endpoint ?? "");
     if (ttl <= 0) return null;
     if (Date.now() - entry.cachedAt > ttl) {
       try {
-        fs6.unlinkSync(filePath);
+        fs7.unlinkSync(filePath);
       } catch {
       }
       return null;
@@ -10566,7 +11003,7 @@ function getCachedByRequest(endpoint, body) {
 function setCache(key, data, ttlMs) {
   if (ttlMs <= 0) return;
   try {
-    fs6.mkdirSync(CACHE_DIR, { recursive: true });
+    fs7.mkdirSync(CACHE_DIR, { recursive: true });
   } catch {
   }
   const entry = {
@@ -10575,7 +11012,7 @@ function setCache(key, data, ttlMs) {
     ttlMs
   };
   try {
-    fs6.writeFileSync(cachePath(key), JSON.stringify(entry));
+    fs7.writeFileSync(cachePath(key), JSON.stringify(entry));
   } catch {
   }
 }
@@ -10596,7 +11033,7 @@ function readableFilename(endpoint, body) {
 }
 function saveReadable(endpoint, body, response, costUsd) {
   try {
-    fs6.mkdirSync(DATA_DIR, { recursive: true });
+    fs7.mkdirSync(DATA_DIR, { recursive: true });
   } catch {
   }
   const filename = readableFilename(endpoint, body);
@@ -10608,14 +11045,14 @@ function saveReadable(endpoint, body, response, costUsd) {
     response
   };
   try {
-    fs6.writeFileSync(path5.join(DATA_DIR, filename), JSON.stringify(entry, null, 2));
+    fs7.writeFileSync(path6.join(DATA_DIR, filename), JSON.stringify(entry, null, 2));
   } catch {
   }
 }
 function appendCostLog(endpoint, costUsd) {
   if (costUsd <= 0) return;
   try {
-    fs6.mkdirSync(path5.dirname(COST_LOG_FILE2), { recursive: true });
+    fs7.mkdirSync(path6.dirname(COST_LOG_FILE2), { recursive: true });
   } catch {
   }
   const entry = {
@@ -10624,7 +11061,7 @@ function appendCostLog(endpoint, costUsd) {
     cost_usd: costUsd
   };
   try {
-    fs6.appendFileSync(COST_LOG_FILE2, JSON.stringify(entry) + "\n");
+    fs7.appendFileSync(COST_LOG_FILE2, JSON.stringify(entry) + "\n");
   } catch {
   }
 }
@@ -10632,7 +11069,7 @@ function saveToCache(endpoint, body, response, costUsd = 0) {
   const ttl = getTtl(endpoint);
   if (ttl > 0) {
     try {
-      fs6.mkdirSync(CACHE_DIR, { recursive: true });
+      fs7.mkdirSync(CACHE_DIR, { recursive: true });
     } catch {
     }
     const key = cacheKey(endpoint, body);
@@ -10644,7 +11081,7 @@ function saveToCache(endpoint, body, response, costUsd = 0) {
       costUsd
     };
     try {
-      fs6.writeFileSync(cachePath(key), JSON.stringify(entry));
+      fs7.writeFileSync(cachePath(key), JSON.stringify(entry));
     } catch {
     }
   }
@@ -10652,14 +11089,14 @@ function saveToCache(endpoint, body, response, costUsd = 0) {
   appendCostLog(endpoint, costUsd);
 }
 function clearCache() {
-  if (!fs6.existsSync(CACHE_DIR)) return 0;
+  if (!fs7.existsSync(CACHE_DIR)) return 0;
   let count = 0;
   try {
-    const files = fs6.readdirSync(CACHE_DIR);
+    const files = fs7.readdirSync(CACHE_DIR);
     for (const file of files) {
       if (file.endsWith(".json")) {
         try {
-          fs6.unlinkSync(path5.join(CACHE_DIR, file));
+          fs7.unlinkSync(path6.join(CACHE_DIR, file));
           count++;
         } catch {
         }
@@ -10670,14 +11107,14 @@ function clearCache() {
   return count;
 }
 function getCostLogSummary() {
-  if (!fs6.existsSync(COST_LOG_FILE2)) {
+  if (!fs7.existsSync(COST_LOG_FILE2)) {
     return { totalUsd: 0, calls: 0, byEndpoint: {} };
   }
   let totalUsd = 0;
   let calls = 0;
   const byEndpoint = {};
   try {
-    const content = fs6.readFileSync(COST_LOG_FILE2, "utf-8").trim();
+    const content = fs7.readFileSync(COST_LOG_FILE2, "utf-8").trim();
     if (!content) return { totalUsd: 0, calls: 0, byEndpoint: {} };
     for (const line of content.split("\n")) {
       if (!line) continue;