@letrquan/book 0.2.0 → 0.3.0

package/dist/{chunk-GTVB4HEM.js → chunk-AQEQX4FF.js}

@@ -1,289 +1,101 @@
+import {
+  escapeInvisibleCharacters
+} from "./chunk-2AAOF5B5.js";
 import {
   systemClock
-} from "./chunk-7N4J557C.js";
-
-// src/debug-log.ts
+} from "./chunk-RT5SATF7.js";
 import {
-  appendFileSync,
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  renameSync,
-  statSync,
-  unlinkSync
-} from "fs";
-import { dirname, join } from "path";
-var DEBUG_ENABLED = process.env.BOOK_DEBUG === "1";
-var UI_DEBUG_ENABLED = process.env.BOOK_DEBUG_UI === "1" || DEBUG_ENABLED;
-var RENDER_DEBUG_ENABLED = process.env.BOOK_DEBUG_RENDER === "1";
-var FLOW_DEBUG_ENABLED = process.env.BOOK_DEBUG_FLOW === "1";
-var debugLogPath;
-var debugLogSizes = /* @__PURE__ */ new Map();
-var DEFAULT_DEBUG_LOG_MAX_BYTES = 5 * 1024 * 1024;
-var MIN_DEBUG_LOG_MAX_BYTES = 4;
-var DEFAULT_DEBUG_LOG_BACKUPS = 3;
-var DEFAULT_LOCAL_DATA_RETENTION_DAYS = 30;
-function positiveInteger(value, fallback) {
-  const parsed = Number(value);
-  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
-}
-function debugLogMaxBytes() {
-  return Math.max(
-    MIN_DEBUG_LOG_MAX_BYTES,
-    positiveInteger(process.env.BOOK_DEBUG_MAX_BYTES, DEFAULT_DEBUG_LOG_MAX_BYTES)
-  );
+  createDebugLogger,
+  isDebugEnabled
+} from "./chunk-62QL5QUP.js";
+
+// src/provider/reliability.ts
+function classifyHttpStatus(status) {
+  if (status === 413) return { code: "context_overflow", retryable: false };
+  if (status === 429) return { code: "rate_limited", retryable: true };
+  if (status === 529) return { code: "overloaded", retryable: true };
+  if (status >= 500 && status < 600) return { code: "server_error", retryable: true };
+  if (status === 408) return { code: "timeout", retryable: true };
+  if (status === 401 || status === 403) return { code: "auth", retryable: false };
+  if (status === 402) return { code: "quota", retryable: false };
+  if (status === 400) return { code: "bad_request", retryable: false };
+  if (status === 404) return { code: "not_found", retryable: false };
+  if (status === 422) return { code: "unprocessable", retryable: false };
+  return { code: "unknown", retryable: false };
 }
-function rotateDebugLog(target, incomingBytes) {
-  if (!existsSync(target)) {
-    debugLogSizes.set(target, 0);
-    return;
+var CAPACITY_OUTAGE_404 = /no\s+(?:endpoints|accounts)\s+found/i;
+var RESET_AFTER = /\(reset after\s*[^)]+\)/i;
+function quotedUpstreamStatus(body) {
+  if (!body) return void 0;
+  const text = body.length > 65536 ? body.slice(0, 65536) : body;
+  const patterns = [
+    /\[[^\]\s]+\]\s*\[(4\d\d)\]:/,
+    /"error"\s*:\s*\{[^{}]*?"code"\s*:\s*"?(4\d\d)(?![\d.])/
+  ];
+  const capacityOutage = CAPACITY_OUTAGE_404.test(text) && RESET_AFTER.test(text);
+  if (capacityOutage) return void 0;
+  for (const pattern of patterns) {
+    const match = text.match(pattern);
+    if (match) return Number(match[1]);
   }
-  const maxBytes = debugLogMaxBytes();
-  const currentBytes = debugLogSizes.get(target) ?? statSync(target).size;
-  debugLogSizes.set(target, currentBytes);
-  if (currentBytes + incomingBytes <= maxBytes) return;
-  const backups = positiveInteger(process.env.BOOK_DEBUG_BACKUPS, DEFAULT_DEBUG_LOG_BACKUPS);
-  const oldest = `${target}.${backups}`;
-  if (existsSync(oldest)) unlinkSync(oldest);
-  for (let index = backups - 1; index >= 1; index--) {
-    const source = `${target}.${index}`;
-    if (existsSync(source)) renameSync(source, `${target}.${index + 1}`);
-  }
-  renameSync(target, `${target}.1`);
-  debugLogSizes.set(target, 0);
-}
-function defaultDebugLogPath() {
-  return join(process.env.BOOK_WORKSPACE || process.cwd(), ".book", "debug.log");
-}
-function getDebugLogPath() {
-  if (process.env.BOOK_DEBUG_STDERR === "1") return void 0;
-  if (process.env.BOOK_DEBUG_FILE) return process.env.BOOK_DEBUG_FILE;
-  if (process.stderr.isTTY) return defaultDebugLogPath();
   return void 0;
 }
-function cleanupDebugLogs(days = DEFAULT_LOCAL_DATA_RETENTION_DAYS, target = getDebugLogPath(), now = Date.now()) {
-  if (!target) return 0;
-  const cutoff = now - Math.max(1, days) * 864e5;
-  const directory = dirname(target);
-  const prefix = `${target.split(/[\\/]/).pop()}.`;
-  let removed = 0;
+function wrappedUpstreamStatus(status, body) {
+  return classifyHttpStatus(status).retryable ? quotedUpstreamStatus(body) : void 0;
+}
+var CONTEXT_OVERFLOW_ERROR_NAMES = /* @__PURE__ */ new Set([
+  "context_length_exceeded",
+  "request_too_large",
+  // llama.cpp's server.
+  "exceed_context_size_error"
+]);
+function errorBodyParts(body) {
+  let parsedJson;
   try {
-    for (const entry of readdirSync(directory, { withFileTypes: true })) {
-      if (!entry.isFile() || !entry.name.startsWith(prefix)) continue;
-      const path = join(directory, entry.name);
-      if (statSync(path).mtimeMs >= cutoff) continue;
-      unlinkSync(path);
-      debugLogSizes.delete(path);
-      removed++;
-    }
+    parsedJson = JSON.parse(body);
   } catch {
-  }
-  return removed;
-}
-function writeDebugLine(line) {
-  const target = debugLogPath ?? (debugLogPath = getDebugLogPath());
-  if (!target) {
-    process.stderr.write(line);
-    return;
-  }
-  try {
-    mkdirSync(dirname(target), { recursive: true });
-    const lineBytes = Buffer.byteLength(line);
-    rotateDebugLog(target, lineBytes);
-    appendFileSync(target, line, "utf8");
-    debugLogSizes.set(target, (debugLogSizes.get(target) ?? 0) + lineBytes);
-  } catch {
-    process.stderr.write(line);
-  }
-}
-function writeSizeBoundedDebugLine(line, maxBytes) {
-  if (Buffer.byteLength(line) <= maxBytes) {
-    writeDebugLine(line);
-    return;
-  }
-  let chunk = "";
-  let chunkBytes = 0;
-  for (const character of line) {
-    const characterBytes = Buffer.byteLength(character);
-    if (chunk && chunkBytes + characterBytes > maxBytes) {
-      writeDebugLine(chunk);
-      chunk = "";
-      chunkBytes = 0;
-    }
-    chunk += character;
-    chunkBytes += characterBytes;
-  }
-  if (chunk) writeDebugLine(chunk);
-}
-var pendingRenderDebug = [];
-var renderDebugFlush = null;
-function writeRenderDebugLine(line) {
-  pendingRenderDebug.push(line);
-  if (renderDebugFlush !== null) return;
-  renderDebugFlush = setImmediate(() => {
-    renderDebugFlush = null;
-    const batch = pendingRenderDebug;
-    pendingRenderDebug = [];
-    const maxBytes = debugLogMaxBytes();
-    let chunk = "";
-    let chunkBytes = 0;
-    for (const pendingLine of batch) {
-      const lineBytes = Buffer.byteLength(pendingLine);
-      if (chunk && chunkBytes + lineBytes > maxBytes) {
-        writeDebugLine(chunk);
-        chunk = "";
-        chunkBytes = 0;
-      }
-      if (lineBytes > maxBytes) {
-        writeSizeBoundedDebugLine(pendingLine, maxBytes);
-        continue;
-      }
-      chunk += pendingLine;
-      chunkBytes += lineBytes;
+    const reachedCap = new TextEncoder().encode(body).byteLength >= ERROR_BODY_MAX_BYTES - 3;
+    if (!reachedCap || !/^\s*(?:\{|\[\s*\{)/.test(body)) {
+      return { message: body, names: [], parsed: false };
     }
-    if (chunk) writeDebugLine(chunk);
-  });
-}
-var namespaceCounters = /* @__PURE__ */ new Map();
-function nextEventId(namespace) {
-  const n = (namespaceCounters.get(namespace) ?? 0) + 1;
-  namespaceCounters.set(namespace, n);
-  return n;
-}
-function isUiDebugEnabled() {
-  return UI_DEBUG_ENABLED;
-}
-function isRenderDebugEnabled() {
-  return RENDER_DEBUG_ENABLED;
-}
-function timestamp() {
-  const now = /* @__PURE__ */ new Date();
-  const h = String(now.getHours()).padStart(2, "0");
-  const m = String(now.getMinutes()).padStart(2, "0");
-  const s = String(now.getSeconds()).padStart(2, "0");
-  const ms = String(now.getMilliseconds()).padStart(3, "0");
-  return `${h}:${m}:${s}.${ms}`;
-}
-function truncate(value, max = 80) {
-  const single = value.replace(/\s+/g, " ").trim();
-  if (single.length <= max) return single;
-  return `${single.slice(0, max)}\u2026`;
-}
-function formatValue(a) {
-  if (typeof a === "string") return a;
-  if (a instanceof Error) return a.message;
-  try {
-    return JSON.stringify(a);
-  } catch {
-    return String(a);
-  }
-}
-function formatMessage(...args) {
-  return args.map(formatValue).join(" ");
-}
-function formatMeta(meta) {
-  const parts = [];
-  for (const [key, value] of Object.entries(meta)) {
-    let repr;
-    if (typeof value === "string") {
-      repr = truncate(value, 120);
-    } else if (value === null) {
-      repr = "null";
-    } else if (value === void 0) {
-      repr = "undefined";
-    } else {
+    const readString = (key) => {
+      const match = body.match(new RegExp(`"${key}"\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`));
+      if (!match) return "";
       try {
-        repr = JSON.stringify(value);
+        return JSON.parse(`"${match[1]}"`);
       } catch {
-        repr = String(value);
+        return "";
       }
-    }
-    parts.push(`${key}=${repr}`);
+    };
+    const message2 = readString("message") || readString("error") || readString("detail");
+    const names = [body.match(/"code"\s*:\s*"([^"]*)"/), body.match(/"type"\s*:\s*"([^"]*)"/)].filter((name) => name !== null).map((name) => name[1]);
+    return { message: message2, names, parsed: true };
   }
-  return parts.join(" ");
-}
-function noop() {
-}
-var NOOP_LOGGER = {
-  debug: noop,
-  info: noop,
-  warn: noop,
-  event: noop
-};
-function makePrefix(namespace, level) {
-  return `[${timestamp()}] [${namespace}] [${level}]`;
-}
-function buildLogger(namespace, write = writeDebugLine) {
+  const root = Array.isArray(parsedJson) ? parsedJson[0] : parsedJson;
+  if (typeof root !== "object" || root === null) {
+    return { message: body, names: [], parsed: false };
+  }
+  const error = root.error;
+  if (typeof error === "string") return { message: error, names: [], parsed: true };
+  const source = typeof error === "object" && error !== null ? error : root;
+  const fallback = root.detail;
+  const message = typeof source.message === "string" ? source.message : typeof fallback === "string" ? fallback : "";
+  const metadata = source.metadata;
+  const raw = metadata?.raw;
   return {
-    debug: (...args) => {
-      write(`${makePrefix(namespace, "DEBUG")} ${formatMessage(...args)}
-`);
-    },
-    info: (...args) => {
-      write(`${makePrefix(namespace, "INFO")} ${formatMessage(...args)}
-`);
-    },
-    warn: (...args) => {
-      write(`${makePrefix(namespace, "WARN")} ${formatMessage(...args)}
-`);
-    },
-    event: (event, meta) => {
-      const suffix = meta && Object.keys(meta).length > 0 ? ` ${formatMeta(meta)}` : "";
-      write(`${makePrefix(namespace, "DEBUG")} ${event}${suffix}
-`);
-    }
+    message,
+    names: [source.code, source.type].filter((name) => typeof name === "string"),
+    raw: typeof raw === "string" ? raw : typeof raw === "object" && raw !== null ? JSON.stringify(raw) : void 0,
+    parsed: true
   };
 }
-function createDebugLogger(namespace) {
-  if (!DEBUG_ENABLED) return NOOP_LOGGER;
-  return buildLogger(namespace);
-}
-function createDebugLoggerWithCounter(namespace) {
-  if (!DEBUG_ENABLED) return NOOP_LOGGER;
-  const wrap = (level) => (...args) => {
-    const id = nextEventId(namespace);
-    writeDebugLine(
-      `[${timestamp()}] [${namespace}] [${level.toUpperCase()}#${id}] ${formatMessage(...args)}
-`
-    );
-  };
-  return {
-    debug: wrap("debug"),
-    info: wrap("info"),
-    warn: wrap("warn"),
-    event: (event, meta) => {
-      const id = nextEventId(namespace);
-      const suffix = meta && Object.keys(meta).length > 0 ? ` ${formatMeta(meta)}` : "";
-      writeDebugLine(`[${timestamp()}] [${namespace}] [DEBUG#${id}] ${event}${suffix}
-`);
-    }
-  };
-}
-function createUiDebugLogger(namespace) {
-  if (!UI_DEBUG_ENABLED) return NOOP_LOGGER;
-  return buildLogger(namespace);
-}
-function createRenderDebugLogger(namespace) {
-  if (!RENDER_DEBUG_ENABLED) return NOOP_LOGGER;
-  return buildLogger(namespace, writeRenderDebugLine);
-}
-
-// src/provider/reliability.ts
-function classifyHttpStatus(status) {
-  if (status === 413) return { code: "context_overflow", retryable: false };
-  if (status === 429) return { code: "rate_limited", retryable: true };
-  if (status === 529) return { code: "overloaded", retryable: true };
-  if (status >= 500 && status < 600) return { code: "server_error", retryable: true };
-  if (status === 408) return { code: "timeout", retryable: true };
-  if (status === 401 || status === 403) return { code: "auth", retryable: false };
-  if (status === 402) return { code: "quota", retryable: false };
-  if (status === 400) return { code: "bad_request", retryable: false };
-  if (status === 404) return { code: "not_found", retryable: false };
-  return { code: "unknown", retryable: false };
+function statesContextOverflow(body) {
+  const { message, names, raw } = errorBodyParts(body);
+  return names.some((name) => CONTEXT_OVERFLOW_ERROR_NAMES.has(name.toLowerCase())) || isContextOverflowError(message) || raw !== void 0 && statesContextOverflow(raw);
 }
 function classifyApiError(status, body) {
-  const code = classifyHttpStatus(status).code;
-  return code === "bad_request" && isContextOverflowError(body) ? "context_overflow" : code;
+  const code = classifyHttpStatus(wrappedUpstreamStatus(status, body) ?? status).code;
+  return code === "bad_request" && statesContextOverflow(body) ? "context_overflow" : code;
 }
 function classifyProviderError(error) {
   if (error instanceof DOMException && error.name === "TimeoutError") return "timeout";
@@ -300,7 +112,7 @@ function formatApiError(status, body) {
     case "context_overflow":
       return `${base} ${detail || "Input exceeds the model context window."} Reduce the conversation or tool output and try again.`;
     case "rate_limited":
-      return `${base} ${detail}. This may be a temporary capacity issue. Try again in a moment.`;
+      return isOversizedForRateLimit(detail) ? `${base} ${detail}. The request is larger than the rate limit allows at once, so it has to shrink; waiting will not help.` : `${base} ${detail}. This may be a temporary capacity issue. Try again in a moment.`;
     case "overloaded":
       return `${base} Repeated 529 Overloaded errors. The API is at capacity \u2014 this is usually temporary. Try again in a moment.`;
     case "server_error":
@@ -317,10 +129,80 @@ function formatApiError(status, body) {
 }
 function isContextOverflowError(error) {
   const normalized = (error instanceof Error ? error.message : String(error)).toLowerCase();
-  return /\b(?:api error:\s*)?413\b/.test(normalized) || normalized.includes("request entity too large") || normalized.includes("payload too large") || normalized.includes("request too large") || normalized.includes("context_length_exceeded") || normalized.includes("maximum context length") || normalized.includes("context window") || normalized.includes("prompt too long") || /prompt\s+is\s+too\s+long/.test(normalized) || /input\s+(?:is\s+)?too\s+long/.test(normalized) || normalized.includes("too many tokens") || /input\s+(?:token\s+count\s+)?exceeds?.*(?:context|limit|maximum)/.test(normalized) || /input\s+exceeds?.*(?:context\s+window|context\s+length|token\s+limit)/.test(normalized) || /maximum\s+context|context\s+(?:length|window|size).*(?:exceed|overflow|too\s+(?:long|large)|maximum)/.test(
+  return /\b(?:api\s+error|http|(?:error|status)(?:\s+code)?)\s*:?\s*413\b/.test(normalized) || normalized.includes("request entity too large") || normalized.includes("payload too large") || normalized.includes("request too large") || normalized.includes("context_length_exceeded") || normalized.includes("maximum context length") || normalized.includes("context window") || normalized.includes("prompt too long") || /prompt\s+is\s+too\s+long/.test(normalized) || /input\s+(?:is\s+)?too\s+long/.test(normalized) || normalized.includes("too many tokens") || // Gemini names the count: `The input token count (1196266) exceeds the maximum …`.
+  /input\s+(?:token\s+count\s+)?(?:\(\d+\)\s+)?exceeds?.*(?:context|limit|maximum)/.test(
+    normalized
+  ) || /input\s+exceeds?.*(?:context\s+window|context\s+length|token\s+limit)/.test(normalized) || /maximum\s+context|context\s+(?:length|window|size).*(?:exceed|overflow|too\s+(?:long|large)|maximum)/.test(
     normalized
   ) || /too\s+many\s+(?:input\s+)?tokens|request\s+too\s+large.*token/.test(normalized);
 }
+function isOversizedForRateLimit(text) {
+  if (!/\brequest too large\b/i.test(text)) return false;
+  const limit = text.match(/\blimit:?\s*(\d+)/i);
+  const requested = text.match(/\brequested:?\s*(\d+)/i);
+  return !limit || !requested || Number(requested[1]) > Number(limit[1]);
+}
+function statedRateLimit(text) {
+  if (!isOversizedForRateLimit(text)) return void 0;
+  const limit = text.match(/\blimit:?\s*(\d+)/i);
+  return limit ? Number(limit[1]) : void 0;
+}
+var ERROR_ENVELOPE_MAX_CHARS = 2e3;
+function isZeroUsage(usage) {
+  return usage != null && usage.promptTokens === 0 && usage.completionTokens === 0 && (usage.cacheReadInputTokens ?? 0) === 0 && (usage.cacheCreationInputTokens ?? 0) === 0;
+}
+function isErrorEnvelopeShape(text, usage) {
+  if (isZeroUsage(usage)) return /^\s*\[Error\]/i.test(text);
+  const trimmed = text.trim();
+  return trimmed.length <= ERROR_ENVELOPE_MAX_CHARS && /^\[Error\]/i.test(trimmed) && !/[\r\n]/.test(trimmed);
+}
+function isUpstreamErrorEnvelope(text, usage) {
+  if (!isErrorEnvelopeShape(text, usage)) return false;
+  return isZeroUsage(usage) || /\brequest id\b/i.test(text) || /help\.openai\.com/i.test(text) || /error occurred while processing/i.test(text);
+}
+var ERROR_BODY_READ_TIMEOUT_MS = 5e3;
+var ERROR_BODY_MAX_BYTES = 65536;
+async function readErrorBody(response, signal) {
+  if (signal?.aborted || !response.body) return "";
+  let reader;
+  try {
+    reader = response.body.getReader();
+  } catch {
+    return "";
+  }
+  const decoder = new TextDecoder();
+  let text = "";
+  let received = 0;
+  let finished = false;
+  const stop = () => {
+    reader.cancel().catch(() => {
+    });
+  };
+  const timer = setTimeout(stop, ERROR_BODY_READ_TIMEOUT_MS);
+  signal?.addEventListener("abort", stop, { once: true });
+  try {
+    while (received < ERROR_BODY_MAX_BYTES) {
+      const chunk = await reader.read();
+      if (chunk.done) {
+        finished = true;
+        break;
+      }
+      const bytes = chunk.value.subarray(0, ERROR_BODY_MAX_BYTES - received);
+      received += bytes.byteLength;
+      text += decoder.decode(bytes, { stream: true });
+    }
+  } catch {
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", stop);
+    if (!finished) stop();
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+  return text + decoder.decode();
+}
 async function fetchWithRetry(url, init, retry, signal, onRetry, logger, clock = systemClock) {
   const startMs = clock.monotonicNowMs();
   const maxAttempts = retry.watchdog ? Number.MAX_SAFE_INTEGER : retry.maxAttempts;
@@ -341,20 +223,48 @@ async function fetchWithRetry(url, init, retry, signal, onRetry, logger, clock =
         delayMs: delay2,
         error: lastError
       });
-      onRetry?.(attempt + 1, maxAttempts > 100 ? -1 : maxAttempts, delay2);
+      onRetry?.(attempt + 1, maxAttempts === Number.MAX_SAFE_INTEGER ? -1 : maxAttempts, delay2);
       await sleep(delay2, signal);
       continue;
     }
     const classification = classifyHttpStatus(response.status);
     if (!classification.retryable) return response;
     lastError = `API error ${response.status}`;
+    const bodyText = await readErrorBody(response, signal);
+    const quoted = quotedUpstreamStatus(bodyText);
+    if (quoted !== void 0 && !classifyHttpStatus(quoted).retryable) {
+      logger?.warn("upstream error quoted in retryable status; not retrying", {
+        status: response.status,
+        upstreamStatus: quoted
+      });
+      return new Response(bodyText, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
+    if ((quoted ?? response.status) === 429 && isOversizedForRateLimit(formatApiError(response.status, bodyText))) {
+      logger?.warn("rate limit on a request too large to ever fit; not retrying", {
+        status: response.status
+      });
+      return new Response(bodyText, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
     const watchdogRetry = retry.watchdog && (response.status === 429 || response.status === 529);
     const effectiveMax = watchdogRetry ? Number.MAX_SAFE_INTEGER : maxAttempts;
-    if (attempt >= effectiveMax || budgetExhausted(clock, startMs, retry.totalBudgetMs))
-      return response;
+    if (attempt >= effectiveMax || budgetExhausted(clock, startMs, retry.totalBudgetMs)) {
+      return new Response(bodyText, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
     const delay = boundedDelay(
       clock,
-      backoffMs(attempt, retry, response.headers.get("retry-after")),
+      backoffMs(attempt, retry, response.headers.get("retry-after"), bodyText),
       startMs,
       retry.totalBudgetMs
     );
@@ -363,11 +273,15 @@ async function fetchWithRetry(url, init, retry, signal, onRetry, logger, clock =
       status: response.status,
       delayMs: delay
     });
-    onRetry?.(attempt + 1, watchdogRetry ? -1 : maxAttempts, delay);
+    onRetry?.(attempt + 1, effectiveMax === Number.MAX_SAFE_INTEGER ? -1 : effectiveMax, delay);
     try {
       await sleep(delay, signal);
     } catch {
-      return response;
+      return new Response(bodyText, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
     }
     try {
       await response.body?.cancel();
@@ -413,11 +327,8 @@ function abortError(signal) {
   return signal.reason instanceof Error ? signal.reason : new Error("Aborted");
 }
 function safeErrorDetail(body) {
-  try {
-    const parsed = JSON.parse(body);
-    if (typeof parsed.error?.message === "string") return parsed.error.message.slice(0, 2e3);
-  } catch {
-  }
+  const { message, parsed } = errorBodyParts(body);
+  if (parsed && message) return message.slice(0, 2e3);
   return body.slice(0, 200);
 }
 function sleep(ms, signal) {
@@ -437,8 +348,8 @@ function sleep(ms, signal) {
     signal?.addEventListener("abort", onAbort, { once: true });
   });
 }
-function backoffMs(attempt, retry, retryAfter) {
-  const retryAfterMs = parseRetryAfter(retryAfter);
+function backoffMs(attempt, retry, retryAfter, body) {
+  const retryAfterMs = parseRetryAfter(retryAfter) ?? parseCooldownReset(body);
   if (retryAfterMs !== void 0) return Math.min(retryAfterMs, retry.maxDelayMs);
   const exponential = Math.min(retry.baseDelayMs * 2 ** attempt, retry.maxDelayMs);
   return Math.round(exponential * (0.5 + Math.random()));
@@ -447,9 +358,40 @@ function parseRetryAfter(value) {
   if (!value) return void 0;
   const seconds = Number(value);
   if (Number.isFinite(seconds) && seconds > 0) return seconds * 1e3;
-  const timestamp2 = Date.parse(value);
-  if (!Number.isFinite(timestamp2)) return void 0;
-  return Math.max(0, timestamp2 - Date.now());
+  const timestamp = Date.parse(value);
+  if (!Number.isFinite(timestamp)) return void 0;
+  return Math.max(0, timestamp - Date.now());
+}
+var COOLDOWN_UNIT_MS = {
+  ms: 1,
+  s: 1e3,
+  sec: 1e3,
+  secs: 1e3,
+  second: 1e3,
+  seconds: 1e3,
+  m: 6e4,
+  min: 6e4,
+  mins: 6e4,
+  minute: 6e4,
+  minutes: 6e4,
+  h: 36e5,
+  hr: 36e5,
+  hrs: 36e5,
+  hour: 36e5,
+  hours: 36e5
+};
+var COOLDOWN_UNIT = /(\d+)\s*(ms|sec(?:ond)?s?|min(?:ute)?s?|h(?:ours?|rs?)?|s|m)(?![a-z])/gi;
+function parseCooldownReset(body) {
+  if (!body) return void 0;
+  const stated = body.match(/\(reset after\s*([^)]+)\)/i);
+  if (!stated) return void 0;
+  let totalMs = 0;
+  let statedUnits = 0;
+  for (const unit of stated[1].matchAll(COOLDOWN_UNIT)) {
+    totalMs += Number(unit[1]) * COOLDOWN_UNIT_MS[unit[2].toLowerCase()];
+    statedUnits++;
+  }
+  return statedUnits > 0 && totalMs > 0 ? totalMs : void 0;
 }
 function budgetExhausted(clock, startMs, budgetMs) {
   return budgetMs > 0 && clock.monotonicNowMs() - startMs >= budgetMs;
@@ -462,12 +404,17 @@ function boundedDelay(clock, delayMs, startMs, budgetMs) {
 // src/provider/openai-compatible.ts
 var log = createDebugLogger("provider");
 function parseToolArguments(raw) {
-  if (!raw.trim()) return {};
+  if (!raw.trim()) return { arguments: {} };
   try {
     const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-  } catch {
-    return { __raw: raw };
+    return {
+      arguments: parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {}
+    };
+  } catch (error) {
+    return {
+      arguments: {},
+      unparsedArguments: { raw, error: error instanceof Error ? error.message : String(error) }
+    };
   }
 }
 function parseReasoningDelta(delta) {
@@ -502,6 +449,64 @@ function flattenMessages(messages) {
     ) : reasoningContent ? ["<reasoning_context>", reasoningContent, "</reasoning_context>", msg.content ?? ""].filter(Boolean).join("\n") : msg.content
   }));
 }
+function parseCompatibleUsage(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const usage = raw;
+  const details = usage.prompt_tokens_details && typeof usage.prompt_tokens_details === "object" ? usage.prompt_tokens_details : {};
+  const tokens = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+  const firstCount = (...values) => {
+    for (const value of values) {
+      const count = tokens(value);
+      if (count > 0) return count;
+    }
+    return 0;
+  };
+  const prompt = tokens(usage.prompt_tokens);
+  const base = {
+    promptTokens: prompt,
+    completionTokens: tokens(usage.completion_tokens),
+    // A provider that omits `total_tokens` would otherwise read as zero context pressure.
+    totalTokens: tokens(usage.total_tokens) || prompt + tokens(usage.completion_tokens)
+  };
+  const topRead = tokens(usage.cache_read_input_tokens);
+  const topWrite = tokens(usage.cache_creation_input_tokens);
+  const normalisedRead = firstCount(
+    details.cached_tokens,
+    usage.prompt_cache_hit_tokens,
+    usage.cached_tokens
+  );
+  const normalisedWrite = firstCount(
+    details.cache_creation_tokens,
+    details.cache_write_tokens,
+    details.cache_creation_input_tokens
+  );
+  const read = normalisedRead || topRead;
+  const write = normalisedWrite || topWrite;
+  if (read === 0 && write === 0) return base;
+  const reportsOpenAiCacheField = [
+    details.cached_tokens,
+    details.cache_creation_tokens,
+    details.cache_write_tokens,
+    details.cache_creation_input_tokens,
+    usage.prompt_cache_hit_tokens,
+    usage.cached_tokens
+  ].some((value) => typeof value === "number");
+  const anthropicPassThrough = !reportsOpenAiCacheField && topRead + topWrite > 0;
+  if (!anthropicPassThrough && read + write <= prompt) {
+    return {
+      ...base,
+      promptTokens: prompt - read - write,
+      cacheReadInputTokens: read,
+      cacheCreationInputTokens: write
+    };
+  }
+  return {
+    ...base,
+    cacheReadInputTokens: read,
+    cacheCreationInputTokens: write,
+    contextTokens: prompt + read + write
+  };
+}
 function convertTools(tools) {
   return tools.map((tool) => ({
     type: "function",
@@ -570,11 +575,12 @@ async function* chatCompletionStream(config, messages, tools, options) {
   }
   log.debug("response received", { status: response.status, ok: response.ok });
   if (!response.ok) {
-    const errorText = await response.text();
+    const errorText = await readErrorBody(response, signal);
     yield {
       type: "error",
       error: formatApiError(response.status, errorText),
-      errorCode: classifyApiError(response.status, errorText)
+      errorCode: classifyApiError(response.status, errorText),
+      upstreamStatus: wrappedUpstreamStatus(response.status, errorText)
     };
     return;
   }
@@ -593,12 +599,24 @@ async function* chatCompletionStream(config, messages, tools, options) {
   const emitToolCalls = function* () {
     for (const part of [...toolCallParts].sort((a, b) => a.index - b.index)) {
       if (!part.id && !part.name) continue;
+      const { arguments: arguments_, unparsedArguments } = parseToolArguments(part.arguments);
+      if (unparsedArguments) {
+        log.warn("tool call arguments are not valid JSON", {
+          index: part.index,
+          id: part.id,
+          name: escapeInvisibleCharacters(part.name),
+          fragments: part.fragments,
+          length: part.arguments.length,
+          head: escapeInvisibleCharacters(part.arguments.slice(0, 120))
+        });
+      }
       yield {
         type: "tool_call",
         toolCall: {
           id: part.id || `tool-${part.index}`,
           name: part.name,
-          arguments: parseToolArguments(part.arguments)
+          arguments: arguments_,
+          ...unparsedArguments ? { unparsedArguments } : {}
         }
       };
     }
@@ -609,7 +627,9 @@ async function* chatCompletionStream(config, messages, tools, options) {
       terminal,
       promptTokens: currentUsage?.promptTokens ?? 0,
       completionTokens: currentUsage?.completionTokens ?? 0,
-      totalTokens: currentUsage?.totalTokens ?? 0
+      totalTokens: currentUsage?.totalTokens ?? 0,
+      cacheReadInputTokens: currentUsage?.cacheReadInputTokens ?? 0,
+      cacheCreationInputTokens: currentUsage?.cacheCreationInputTokens ?? 0
     });
     yield {
       type: "done",
@@ -631,13 +651,8 @@ async function* chatCompletionStream(config, messages, tools, options) {
       const parsed = JSON.parse(data);
       if (typeof parsed.model === "string") responseModel = parsed.model;
       if (typeof parsed.id === "string") responseId = parsed.id;
-      if (parsed.usage) {
-        currentUsage = {
-          promptTokens: parsed.usage.prompt_tokens ?? 0,
-          completionTokens: parsed.usage.completion_tokens ?? 0,
-          totalTokens: parsed.usage.total_tokens ?? 0
-        };
-      }
+      const usage = parseCompatibleUsage(parsed.usage);
+      if (usage) currentUsage = usage;
       const choice = parsed.choices?.[0];
       if (!choice) return false;
       const finishReason = choice.finish_reason;
@@ -646,15 +661,19 @@ async function* chatCompletionStream(config, messages, tools, options) {
       if (!delta) return false;
       const reasoning = parseReasoningDelta(delta);
       if (reasoning) {
+        if (retry.thinkingStallTimeoutMs) {
+          stallTimeoutMs = Math.max(stallTimeoutMs, retry.thinkingStallTimeoutMs);
+        }
         log.debug("stream reasoning", { len: reasoning.length });
         yield { type: "reasoning", reasoning };
       }
       if (delta.content) {
+        stallTimeoutMs = startingStallTimeoutMs;
         log.debug("stream text", { len: delta.content.length });
         yield { type: "text", content: delta.content };
       }
       if (delta.tool_calls) {
-        log.debug("stream tool_call delta", { count: delta.tool_calls.length });
+        stallTimeoutMs = startingStallTimeoutMs;
         for (const tc of delta.tool_calls) {
           const explicitIndex = Number.isInteger(tc.index) ? tc.index : void 0;
           let index = explicitIndex;
@@ -666,19 +685,32 @@ async function* chatCompletionStream(config, messages, tools, options) {
           }
           let part = toolCallParts.find((p) => p.index === index);
           if (!part) {
-            part = { index, id: "", name: "", arguments: "" };
+            part = { index, id: "", name: "", arguments: "", fragments: 0 };
             toolCallParts.push(part);
           }
           if (tc.id) part.id = tc.id;
           if (tc.function?.name) part.name = tc.function.name;
-          if (tc.function?.arguments) part.arguments += tc.function.arguments;
+          if (tc.function?.arguments) {
+            if (part.fragments === 0 && isDebugEnabled()) {
+              log.debug("stream tool_call delta", {
+                index,
+                id: tc.id,
+                name: escapeInvisibleCharacters(tc.function.name ?? ""),
+                argumentsLength: tc.function.arguments.length,
+                argumentsHead: escapeInvisibleCharacters(tc.function.arguments.slice(0, 120))
+              });
+            }
+            part.arguments += tc.function.arguments;
+            part.fragments++;
+          }
         }
       }
     } catch {
     }
     return false;
   };
-  const stallTimeoutMs = reasoningEnabled && retry.thinkingStallTimeoutMs ? Math.max(retry.streamStallTimeoutMs, retry.thinkingStallTimeoutMs) : retry.streamStallTimeoutMs;
+  const startingStallTimeoutMs = reasoningEnabled && retry.thinkingStallTimeoutMs ? Math.max(retry.streamStallTimeoutMs, retry.thinkingStallTimeoutMs) : retry.streamStallTimeoutMs;
+  let stallTimeoutMs = startingStallTimeoutMs;
   try {
     while (true) {
       const result = await readStreamChunk(reader, signal, stallTimeoutMs);
@@ -743,23 +775,20 @@ async function* chatCompletionStream(config, messages, tools, options) {
 }
 
 export {
-  DEFAULT_LOCAL_DATA_RETENTION_DAYS,
-  positiveInteger,
-  getDebugLogPath,
-  cleanupDebugLogs,
-  isUiDebugEnabled,
-  isRenderDebugEnabled,
-  createDebugLogger,
-  createDebugLoggerWithCounter,
-  createUiDebugLogger,
-  createRenderDebugLogger,
+  wrappedUpstreamStatus,
   classifyApiError,
   classifyProviderError,
   formatApiError,
   isContextOverflowError,
+  isOversizedForRateLimit,
+  statedRateLimit,
+  isErrorEnvelopeShape,
+  isUpstreamErrorEnvelope,
+  readErrorBody,
   fetchWithRetry,
   readStreamChunk,
+  parseCompatibleUsage,
   convertTools,
   chatCompletionStream
 };
-//# sourceMappingURL=chunk-GTVB4HEM.js.map
+//# sourceMappingURL=chunk-AQEQX4FF.js.map