@letrquan/book 0.3.0 → 0.4.0-beta.0

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

@@ -1,5 +1,6 @@
 import {
-  escapeInvisibleCharacters
+  escapeInvisibleCharacters,
+  foldControlCharacters
 } from "./chunk-2AAOF5B5.js";
 import {
   systemClock
@@ -7,7 +8,7 @@ import {
 import {
   createDebugLogger,
   isDebugEnabled
-} from "./chunk-62QL5QUP.js";
+} from "./chunk-OJBMDM5H.js";
 
 // src/provider/reliability.ts
 function classifyHttpStatus(status) {
@@ -49,6 +50,98 @@ var CONTEXT_OVERFLOW_ERROR_NAMES = /* @__PURE__ */ new Set([
   // llama.cpp's server.
   "exceed_context_size_error"
 ]);
+var MODEL_UNAVAILABLE_ERROR_NAMES = /* @__PURE__ */ new Set([
+  "model_not_found",
+  "model_not_available",
+  "model_unavailable"
+]);
+var MODEL_GONE_PHRASES = [
+  "no longer available",
+  "no longer supported",
+  "not found",
+  "does not exist",
+  "is not supported",
+  "not available",
+  "has been retired",
+  "has been removed",
+  "has been deprecated"
+];
+var CHOOSE_ANOTHER_MODEL = /(?:select|choose)\s+(?:another|a\s+different)\s+model\b(?!\s+provider\b)/i;
+var MODEL_GONE_PROXIMITY_CHARS = 60;
+var CREDENTIAL_WORD = /\b(?:api\s+key|key|token|credential)s?\b/i;
+function splitSentences(text) {
+  return text.split(/[.!?:;]+(?:\s+|$)|[\r\n]+/);
+}
+var INSUFFICIENT_QUOTA_ERROR_NAMES = /* @__PURE__ */ new Set(["insufficient_quota"]);
+function hasInsufficientQuotaName(body) {
+  if (!body) return false;
+  const { names, raw } = errorBodyParts(body);
+  if (names.some((name) => INSUFFICIENT_QUOTA_ERROR_NAMES.has(name.toLowerCase()))) {
+    return true;
+  }
+  return raw !== void 0 && hasInsufficientQuotaName(raw);
+}
+var SPENT_LIMIT_VERBS = /\b(?:reached|exceeded|exhausted|hit|used\s+up|spent|r(?:un|an)\s+out|depleted)\b/i;
+var SPENT_USAGE_LIMIT_PHRASES = /\b(?:usage\s+limits?|plan\s+limits?|quotas?|subscription\s+limits?|limits?\s+for\s+your\s+plan)\b/i;
+var LONG_WINDOW_PHRASES = /\b(?:weekly|daily|monthly|\d+(?:\.\d+)?(?:-|\s+)hours?|per\s+(?:day|week|month))\b/i;
+var SHORT_WINDOW_PHRASES = /\b(?:per\s+min(?:ute)?|per\s+sec(?:ond)?|rpm|tpm|rps)\b/i;
+function statesSpentUsageLimit(body) {
+  if (!body) return false;
+  const { message, raw } = errorBodyParts(body);
+  const saysIt = (text) => {
+    if (!text || SHORT_WINDOW_PHRASES.test(text)) return false;
+    for (const sentence of splitSentences(text)) {
+      if (SPENT_LIMIT_VERBS.test(sentence) && SPENT_USAGE_LIMIT_PHRASES.test(sentence) && LONG_WINDOW_PHRASES.test(sentence)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  return saysIt(message) || raw !== void 0 && statesSpentUsageLimit(raw);
+}
+var ABSOLUTE_RESET_PATTERN = /\b(?:resets?)\s+(?:at|on)\s+(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2}))\b/i;
+function parseAbsoluteReset(body) {
+  if (!body) return void 0;
+  const { message, raw } = errorBodyParts(body);
+  const match = message.match(ABSOLUTE_RESET_PATTERN);
+  if (match) {
+    const timestamp = Date.parse(match[1]);
+    if (Number.isFinite(timestamp)) {
+      return { epochMs: timestamp, iso: match[1] };
+    }
+  }
+  if (raw !== void 0) {
+    return parseAbsoluteReset(raw);
+  }
+  return void 0;
+}
+function statesModelUnavailable(body, effectiveStatus) {
+  const { message, names, raw } = errorBodyParts(body);
+  if (names.some((name) => MODEL_UNAVAILABLE_ERROR_NAMES.has(name.toLowerCase()))) return true;
+  if (effectiveStatus === 404 && names.some((name) => name.toLowerCase() === "not_found_error") && message.trim().toLowerCase().startsWith("model:")) {
+    return true;
+  }
+  const saysIt = (text) => {
+    for (const sentence of splitSentences(text)) {
+      if (CREDENTIAL_WORD.test(sentence)) continue;
+      if (CHOOSE_ANOTHER_MODEL.test(sentence)) return true;
+      const lower = sentence.toLowerCase();
+      const modelWords = [...lower.matchAll(/\bmodels?\b/g)].map((m) => m.index);
+      if (modelWords.length === 0) continue;
+      for (const phrase of MODEL_GONE_PHRASES) {
+        let gone = lower.indexOf(phrase);
+        while (gone >= 0) {
+          if (modelWords.some((at) => at < gone && gone - at <= MODEL_GONE_PROXIMITY_CHARS)) {
+            return true;
+          }
+          gone = lower.indexOf(phrase, gone + 1);
+        }
+      }
+    }
+    return false;
+  };
+  return saysIt(message) || raw !== void 0 && statesModelUnavailable(raw, effectiveStatus);
+}
 function errorBodyParts(body) {
   let parsedJson;
   try {
@@ -93,38 +186,129 @@ 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(wrappedUpstreamStatus(status, body) ?? status).code;
+function classifyApiError(status, body, quotedStatus) {
+  const effective = quotedStatus !== void 0 ? classifyHttpStatus(status).retryable ? quotedStatus : status : wrappedUpstreamStatus(status, body) ?? status;
+  if (effective === 429) {
+    if (hasInsufficientQuotaName(body)) return "quota";
+    if (statesSpentUsageLimit(body)) return "usage_limit";
+  }
+  const code = classifyHttpStatus(effective).code;
+  if ((effective === 403 || effective === 404) && statesModelUnavailable(body, effective)) {
+    return "model_unavailable";
+  }
   return code === "bad_request" && statesContextOverflow(body) ? "context_overflow" : code;
 }
 function classifyProviderError(error) {
+  if (error instanceof ProviderRedirectError) return "redirect";
   if (error instanceof DOMException && error.name === "TimeoutError") return "timeout";
   const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
   if (message.includes("timed out") || message.includes("timeout")) return "timeout";
   if (isContextOverflowError(message)) return "context_overflow";
   return "network";
 }
-function formatApiError(status, body) {
-  const code = classifyApiError(status, body);
+function safeModelUnavailableDetail(body) {
+  const { raw } = errorBodyParts(body);
+  const main = safeErrorDetail(body);
+  if (raw) {
+    const rawDetail = safeErrorDetail(raw);
+    if (rawDetail && rawDetail !== main) {
+      return main ? `${main}: ${rawDetail}` : rawDetail;
+    }
+  }
+  return main || "The provider did not describe why";
+}
+function requestOrigin(request) {
+  let host;
+  try {
+    host = request?.url ? new URL(request.url).host : void 0;
+  } catch {
+    host = void 0;
+  }
+  return [host && `from ${host}`, request?.model && `for model ${request.model}`].filter(Boolean).join(" ");
+}
+function isUninformativeDetail(text) {
+  if (/^(?:\d{3}\s+)?page not found\.?$/i.test(text)) return true;
+  if (isHtmlDetail(text)) return true;
+  if (!/^[[{]/.test(text)) return false;
+  try {
+    const parsed = JSON.parse(text);
+    if (Array.isArray(parsed)) return parsed.length === 0;
+    return typeof parsed === "object" && parsed !== null && Object.keys(parsed).length === 0;
+  } catch {
+    return false;
+  }
+}
+function isHtmlDetail(text) {
+  return /^<(?:!doctype\s+html|html|head|body)\b/i.test(text);
+}
+var MAX_SHOWN_TITLE_CHARS = 100;
+function describeHtmlPage(body) {
+  const title = body.match(/<title[^>]*>([\s\S]*?)<\/title>/i)?.[1];
+  const shown = title ? foldControlCharacters(title).replace(/\s+/g, " ").trim() : "";
+  if (!shown) return "an HTML page";
+  const clipped = shown.length > MAX_SHOWN_TITLE_CHARS ? `${shown.slice(0, MAX_SHOWN_TITLE_CHARS)}\u2026` : shown;
+  return `an HTML page titled "${clipped}"`;
+}
+function detailSentence(detail, request, body = detail) {
+  const text = detail.trim();
+  const origin = requestOrigin(request);
+  if (!text) {
+    const absent = request?.bodyReceived === false ? "no response body received" : "empty response body";
+    return { sentence: `${origin ? `${origin} ` : ""}(${absent}).`, rewritten: false };
+  }
+  const uninformative = isUninformativeDetail(text);
+  const shown = isHtmlDetail(text) ? describeHtmlPage(body) : text;
+  const sentence = /[.!?]$/.test(shown) ? shown : `${shown}.`;
+  const hinted = uninformative && origin !== "";
+  return {
+    sentence: hinted ? `${sentence} The reply came ${origin}.` : sentence,
+    rewritten: hinted || shown !== text
+  };
+}
+function resetStatement(said, resetIso, clause) {
+  return said.includes(resetIso) ? "" : clause;
+}
+function formatApiError(status, body, quotedStatus, request) {
+  const code = classifyApiError(status, body, quotedStatus);
   const detail = safeErrorDetail(body);
+  const { sentence: said, rewritten } = detailSentence(detail, request, body);
   const base = `API Error: ${status}`;
   switch (code) {
     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 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.`;
+      return `${base} ${detail.trim() ? said : "Input exceeds the model context window."} Reduce the conversation or tool output and try again.`;
+    case "rate_limited": {
+      if (isOversizedForRateLimit(detail)) {
+        return `${base} ${said} The request is larger than the rate limit allows at once, so it has to shrink; waiting will not help.`;
+      }
+      const reset = parseAbsoluteReset(body);
+      if (reset !== void 0 && reset.epochMs > Date.now()) {
+        const resetClause = resetStatement(said, reset.iso, ` It resets at ${reset.iso}.`);
+        return `${base} ${said}${resetClause} Wait for the reset, then try again.`;
+      }
+      return `${base} ${said} 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":
-      return `${base} ${detail}. This is a server-side issue, usually temporary \u2014 try again in a moment.`;
+      return `${base} ${said} This is a server-side issue, usually temporary \u2014 try again in a moment.`;
     case "timeout":
       return "Request timed out. Check your network connection and try again.";
     case "auth":
-      return `${base} ${detail}. Check BOOK_API_KEY, or provider.<id>.apiKey in settings.`;
+      return `${base} ${said} Check BOOK_API_KEY, or provider.<id>.apiKey in settings.`;
+    case "model_unavailable": {
+      const modelDetail = detailSentence(safeModelUnavailableDetail(body)).sentence;
+      return `${base} ${modelDetail} This model is not available on this provider or route \u2014 choose another with --model or /model.`;
+    }
+    case "usage_limit": {
+      const reset = parseAbsoluteReset(body);
+      const resetClause = reset !== void 0 ? resetStatement(said, reset.iso, `; it resets at ${reset.iso}`) : "";
+      return `${base} ${said} The usage limit for this plan is spent${resetClause}. Wait for the reset, or choose another model with --model or /model.`;
+    }
     case "quota":
-      return `${base} ${detail}. Check your usage/credits.`;
+      return `${base} ${said} Check your usage/credits.`;
     default:
-      return `${base} ${detail}`;
+      if (detail.trim() && !rewritten) return `${base} ${detail}`;
+      return code === "not_found" ? `${base} ${said} Check the base URL and model id.` : `${base} ${said}`;
   }
 }
 function isContextOverflowError(error) {
@@ -156,25 +340,31 @@ function isErrorEnvelopeShape(text, usage) {
   const trimmed = text.trim();
   return trimmed.length <= ERROR_ENVELOPE_MAX_CHARS && /^\[Error\]/i.test(trimmed) && !/[\r\n]/.test(trimmed);
 }
+var ROUTER_FAILED_RESPONSE = /^\s*\[Error\]\s*The model failed to generate a response\.?\s*$/i;
 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);
+  return isZeroUsage(usage) || /\brequest id\b/i.test(text) || /help\.openai\.com/i.test(text) || /error occurred while processing/i.test(text) || ROUTER_FAILED_RESPONSE.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 "";
+  if (response instanceof BufferedErrorResponse) {
+    return { text: response.bufferedText, received: response.bodyReceived };
+  }
+  if (signal?.aborted) return { text: "", received: false };
+  if (!response.body) return { text: "", received: true };
   let reader;
   try {
     reader = response.body.getReader();
   } catch {
-    return "";
+    return { text: "", received: false };
   }
   const decoder = new TextDecoder();
   let text = "";
   let received = 0;
-  let finished = false;
+  let interrupted = false;
   const stop = () => {
+    interrupted = true;
     reader.cancel().catch(() => {
     });
   };
@@ -183,25 +373,72 @@ async function readErrorBody(response, signal) {
   try {
     while (received < ERROR_BODY_MAX_BYTES) {
       const chunk = await reader.read();
-      if (chunk.done) {
-        finished = true;
-        break;
-      }
+      if (chunk.done) break;
       const bytes = chunk.value.subarray(0, ERROR_BODY_MAX_BYTES - received);
       received += bytes.byteLength;
       text += decoder.decode(bytes, { stream: true });
     }
   } catch {
+    interrupted = true;
   } finally {
     clearTimeout(timer);
     signal?.removeEventListener("abort", stop);
-    if (!finished) stop();
+    reader.cancel().catch(() => {
+    });
     try {
       reader.releaseLock();
     } catch {
     }
   }
-  return text + decoder.decode();
+  return { text: text + decoder.decode(), received: received > 0 || !interrupted };
+}
+var BufferedErrorResponse = class extends Response {
+  bufferedText;
+  bodyReceived;
+  constructor(body, init, bodyReceived) {
+    super(body, init);
+    this.bufferedText = body;
+    this.bodyReceived = bodyReceived;
+  }
+};
+var ProviderRedirectError = class extends Error {
+  constructor(status, target) {
+    const answered = status === 0 ? "answered with a redirect" : `answered HTTP ${status}`;
+    super(
+      target === void 0 ? `Provider endpoint ${answered}${status === 0 ? " that has" : " with"} no redirect target Book could read, and Book does not follow provider redirects. Check the provider's base URL.` : `Provider endpoint ${answered}${status === 0 ? "" : " with a redirect"} to ${target}, and Book does not follow provider redirects. If that host is the endpoint you meant, set the provider's base URL to that address without the endpoint path Book adds (https://gw.example/v1/chat/completions becomes https://gw.example/v1).`
+    );
+    this.status = status;
+    this.target = target;
+    this.name = "ProviderRedirectError";
+  }
+  status;
+  target;
+};
+function sanitizeRedirectTarget(location, requestUrl) {
+  if (!location) return void 0;
+  try {
+    const target = new URL(location, requestUrl);
+    if (!target.host) return void 0;
+    return `${target.protocol}//${target.host}${target.pathname}`;
+  } catch {
+    return void 0;
+  }
+}
+function isRedirectResponse(response) {
+  return response.type === "opaqueredirect" || response.status >= 300 && response.status <= 399;
+}
+async function cancelBody(response) {
+  try {
+    await response.body?.cancel();
+  } catch {
+  }
+}
+async function refuseRedirect(response, requestUrl) {
+  await cancelBody(response);
+  return new ProviderRedirectError(
+    response.status,
+    sanitizeRedirectTarget(response.headers.get("location"), requestUrl)
+  );
 }
 async function fetchWithRetry(url, init, retry, signal, onRetry, logger, clock = systemClock) {
   const startMs = clock.monotonicNowMs();
@@ -212,7 +449,7 @@ async function fetchWithRetry(url, init, retry, signal, onRetry, logger, clock =
     const fetchSignal = requestSignal(signal, retry.requestTimeoutMs);
     let response;
     try {
-      response = await fetch(url, { ...init, signal: fetchSignal });
+      response = await fetch(url, { ...init, redirect: "manual", signal: fetchSignal });
     } catch (error) {
       if (signal?.aborted) throw error;
       lastError = error instanceof Error ? error.message : String(error);
@@ -227,36 +464,73 @@ async function fetchWithRetry(url, init, retry, signal, onRetry, logger, clock =
       await sleep(delay2, signal);
       continue;
     }
+    if (isRedirectResponse(response)) throw await refuseRedirect(response, url);
     const classification = classifyHttpStatus(response.status);
     if (!classification.retryable) return response;
     lastError = `API error ${response.status}`;
-    const bodyText = await readErrorBody(response, signal);
+    const errorBody = await readErrorBody(response, signal);
+    const bodyText = errorBody.text;
+    const buffered = (init2) => new BufferedErrorResponse(bodyText, init2, errorBody.received);
     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, {
+      return buffered({
         status: response.status,
         statusText: response.statusText,
         headers: response.headers
       });
     }
-    if ((quoted ?? response.status) === 429 && isOversizedForRateLimit(formatApiError(response.status, bodyText))) {
+    const errorCode = classifyApiError(response.status, bodyText, quoted);
+    if ((errorCode === "quota" || errorCode === "usage_limit") && !retry.watchdog) {
+      logger?.warn("usage limit reached; not retrying", {
+        status: response.status
+      });
+      return buffered({
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
+    if ((quoted ?? response.status) === 429 && isOversizedForRateLimit(formatApiError(response.status, bodyText, quoted))) {
       logger?.warn("rate limit on a request too large to ever fit; not retrying", {
         status: response.status
       });
-      return new Response(bodyText, {
+      return buffered({
         status: response.status,
         statusText: response.statusText,
         headers: response.headers
       });
     }
+    const stated = statedWait(response.headers.get("retry-after"), bodyText);
+    if ((quoted ?? response.status) === 429 && !retry.watchdog) {
+      if (stated !== void 0) {
+        const attemptsWaitMs = (maxAttempts - attempt) * retry.maxDelayMs;
+        const remainingBudgetMs = retry.totalBudgetMs > 0 ? Math.max(0, retry.totalBudgetMs - (clock.monotonicNowMs() - startMs)) : void 0;
+        const remainingWaitMs = remainingBudgetMs !== void 0 ? Math.min(remainingBudgetMs, attemptsWaitMs) : attemptsWaitMs;
+        const stopsCall = stated.waitMs > remainingWaitMs && (stated.source === "reset-time" || stated.waitMs >= FAR_STATED_WAIT_MS);
+        if (stopsCall) {
+          logger?.warn("stated wait beyond retry budget; not retrying", {
+            status: response.status,
+            source: stated.source
+          });
+          const init2 = {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers
+          };
+          const wholeCallMs = maxAttempts * retry.maxDelayMs;
+          const farWait = stated.waitMs >= FAR_STATED_WAIT_MS && stated.waitMs > (retry.totalBudgetMs > 0 ? Math.min(retry.totalBudgetMs, wholeCallMs) : wholeCallMs);
+          return farWait ? new WaitStoppedResponse(bodyText, init2, stated, errorBody.received) : buffered(init2);
+        }
+      }
+    }
     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 new Response(bodyText, {
+      return buffered({
         status: response.status,
         statusText: response.statusText,
         headers: response.headers
@@ -264,7 +538,7 @@ async function fetchWithRetry(url, init, retry, signal, onRetry, logger, clock =
     }
     const delay = boundedDelay(
       clock,
-      backoffMs(attempt, retry, response.headers.get("retry-after"), bodyText),
+      backoffMs(attempt, retry, stated),
       startMs,
       retry.totalBudgetMs
     );
@@ -277,16 +551,13 @@ async function fetchWithRetry(url, init, retry, signal, onRetry, logger, clock =
     try {
       await sleep(delay, signal);
     } catch {
-      return new Response(bodyText, {
+      return buffered({
         status: response.status,
         statusText: response.statusText,
         headers: response.headers
       });
     }
-    try {
-      await response.body?.cancel();
-    } catch {
-    }
+    await cancelBody(response);
   }
   throw new Error(lastError ?? "request failed after retries");
 }
@@ -348,9 +619,54 @@ function sleep(ms, signal) {
     signal?.addEventListener("abort", onAbort, { once: true });
   });
 }
-function backoffMs(attempt, retry, retryAfter, body) {
-  const retryAfterMs = parseRetryAfter(retryAfter) ?? parseCooldownReset(body);
-  if (retryAfterMs !== void 0) return Math.min(retryAfterMs, retry.maxDelayMs);
+var FAR_STATED_WAIT_MS = 15 * 6e4;
+function statedWait(retryAfter, body) {
+  const header = parseRetryAfter(retryAfter);
+  const cooldown = header === void 0 ? parseCooldownReset(body) : void 0;
+  const relative = header !== void 0 ? { waitMs: header, source: "retry-after" } : cooldown !== void 0 ? { waitMs: cooldown, source: "cooldown" } : void 0;
+  const reset = parseAbsoluteReset(body);
+  const resetWaitMs = reset !== void 0 ? reset.epochMs - Date.now() : 0;
+  if (reset !== void 0 && resetWaitMs > 0 && (relative === void 0 || resetWaitMs > relative.waitMs)) {
+    return { waitMs: resetWaitMs, source: "reset-time", resetIso: reset.iso };
+  }
+  return relative;
+}
+var WaitStoppedResponse = class extends BufferedErrorResponse {
+  statedWait;
+  constructor(body, init, wait, bodyReceived) {
+    super(body, init, bodyReceived);
+    this.statedWait = wait;
+  }
+};
+function statedWaitStop(response) {
+  return response instanceof WaitStoppedResponse ? response.statedWait : void 0;
+}
+function describeWait(waitMs) {
+  const count = (value, unit) => `${value} ${unit}${value === 1 ? "" : "s"}`;
+  const seconds = Math.max(1, Math.round(waitMs / 1e3));
+  if (seconds < 90) return count(seconds, "second");
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 90) return count(minutes, "minute");
+  const hours = Math.round(minutes / 60);
+  if (hours < 48) return count(hours, "hour");
+  return count(Math.round(hours / 24), "day");
+}
+function formatStatedWaitError(status, body, stop, request) {
+  const said = detailSentence(safeErrorDetail(body), request, body).sentence;
+  const when = stop.resetIso !== void 0 ? `The limit resets${resetStatement(said, stop.resetIso, ` at ${stop.resetIso},`)} in about ${describeWait(stop.waitMs)}` : `The provider asks for a wait of about ${describeWait(stop.waitMs)}`;
+  return `API Error: ${status} ${said} ${when}, longer than this request will wait. Wait for the reset, or choose another model with --model or /model.`;
+}
+function statedWaitErrorEvent(response, errorText, request) {
+  const waitStop = statedWaitStop(response);
+  return {
+    type: "error",
+    error: waitStop ? formatStatedWaitError(response.status, errorText, waitStop, request) : formatApiError(response.status, errorText, void 0, request),
+    errorCode: waitStop ? "rate_limit_wait" : classifyApiError(response.status, errorText),
+    upstreamStatus: wrappedUpstreamStatus(response.status, errorText)
+  };
+}
+function backoffMs(attempt, retry, stated) {
+  if (stated !== void 0) return Math.min(stated.waitMs, retry.maxDelayMs);
   const exponential = Math.min(retry.baseDelayMs * 2 ** attempt, retry.maxDelayMs);
   return Math.round(exponential * (0.5 + Math.random()));
 }
@@ -383,7 +699,13 @@ var COOLDOWN_UNIT_MS = {
 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);
+  const { message, raw } = errorBodyParts(body);
+  const own = cooldownIn(message);
+  if (own !== void 0) return own;
+  return raw !== void 0 ? parseCooldownReset(raw) : void 0;
+}
+function cooldownIn(text) {
+  const stated = text.match(/\(reset after\s*([^)]+)\)/i);
   if (!stated) return void 0;
   let totalMs = 0;
   let statedUnits = 0;
@@ -575,13 +897,12 @@ async function* chatCompletionStream(config, messages, tools, options) {
   }
   log.debug("response received", { status: response.status, ok: response.ok });
   if (!response.ok) {
-    const errorText = await readErrorBody(response, signal);
-    yield {
-      type: "error",
-      error: formatApiError(response.status, errorText),
-      errorCode: classifyApiError(response.status, errorText),
-      upstreamStatus: wrappedUpstreamStatus(response.status, errorText)
-    };
+    const errorBody = await readErrorBody(response, signal);
+    yield statedWaitErrorEvent(response, errorBody.text, {
+      url,
+      model: config.model,
+      bodyReceived: errorBody.received
+    });
     return;
   }
   const reader = response.body?.getReader();
@@ -600,6 +921,15 @@ async function* chatCompletionStream(config, messages, tools, options) {
     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);
+      const emptyOnWire = !part.arguments.trim();
+      if (emptyOnWire) {
+        log.warn("tool call arrived with empty arguments", {
+          index: part.index,
+          id: part.id,
+          name: escapeInvisibleCharacters(part.name),
+          fragments: part.fragments
+        });
+      }
       if (unparsedArguments) {
         log.warn("tool call arguments are not valid JSON", {
           index: part.index,
@@ -616,7 +946,8 @@ async function* chatCompletionStream(config, messages, tools, options) {
           id: part.id || `tool-${part.index}`,
           name: part.name,
           arguments: arguments_,
-          ...unparsedArguments ? { unparsedArguments } : {}
+          ...unparsedArguments ? { unparsedArguments } : {},
+          ...emptyOnWire ? { emptyOnWire: true } : {}
         }
       };
     }
@@ -661,9 +992,7 @@ 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);
-        }
+        stallTimeoutMs = retry.thinkingStallTimeoutMs ? Math.max(startingStallTimeoutMs, retry.thinkingStallTimeoutMs) : startingStallTimeoutMs;
         log.debug("stream reasoning", { len: reasoning.length });
         yield { type: "reasoning", reasoning };
       }
@@ -710,7 +1039,8 @@ async function* chatCompletionStream(config, messages, tools, options) {
     return false;
   };
   const startingStallTimeoutMs = reasoningEnabled && retry.thinkingStallTimeoutMs ? Math.max(retry.streamStallTimeoutMs, retry.thinkingStallTimeoutMs) : retry.streamStallTimeoutMs;
-  let stallTimeoutMs = startingStallTimeoutMs;
+  const firstDeltaApplies = !reasoningEnabled && config.modelInfo?.effort !== false;
+  let stallTimeoutMs = firstDeltaApplies ? Math.max(startingStallTimeoutMs, retry.firstDeltaStallTimeoutMs ?? 0) : startingStallTimeoutMs;
   try {
     while (true) {
       const result = await readStreamChunk(reader, signal, stallTimeoutMs);
@@ -775,20 +1105,20 @@ async function* chatCompletionStream(config, messages, tools, options) {
 }
 
 export {
-  wrappedUpstreamStatus,
-  classifyApiError,
   classifyProviderError,
-  formatApiError,
   isContextOverflowError,
   isOversizedForRateLimit,
   statedRateLimit,
   isErrorEnvelopeShape,
   isUpstreamErrorEnvelope,
   readErrorBody,
+  isRedirectResponse,
+  refuseRedirect,
   fetchWithRetry,
   readStreamChunk,
+  statedWaitErrorEvent,
   parseCompatibleUsage,
   convertTools,
   chatCompletionStream
 };
-//# sourceMappingURL=chunk-AQEQX4FF.js.map
+//# sourceMappingURL=chunk-AHC7OU75.js.map