@letrquan/book 0.2.0 → 0.4.0-beta.0

package/dist/chunk-AHC7OU75.js

@@ -0,0 +1,1124 @@
+import {
+  escapeInvisibleCharacters,
+  foldControlCharacters
+} from "./chunk-2AAOF5B5.js";
+import {
+  systemClock
+} from "./chunk-RT5SATF7.js";
+import {
+  createDebugLogger,
+  isDebugEnabled
+} from "./chunk-OJBMDM5H.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 };
+}
+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]);
+  }
+  return void 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"
+]);
+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 {
+    parsedJson = JSON.parse(body);
+  } catch {
+    const reachedCap = new TextEncoder().encode(body).byteLength >= ERROR_BODY_MAX_BYTES - 3;
+    if (!reachedCap || !/^\s*(?:\{|\[\s*\{)/.test(body)) {
+      return { message: body, names: [], parsed: false };
+    }
+    const readString = (key) => {
+      const match = body.match(new RegExp(`"${key}"\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`));
+      if (!match) return "";
+      try {
+        return JSON.parse(`"${match[1]}"`);
+      } catch {
+        return "";
+      }
+    };
+    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 };
+  }
+  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 {
+    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 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, 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 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.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} ${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} ${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} ${said} Check your usage/credits.`;
+    default:
+      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) {
+  const normalized = (error instanceof Error ? error.message : String(error)).toLowerCase();
+  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);
+}
+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) || ROUTER_FAILED_RESPONSE.test(text);
+}
+var ERROR_BODY_READ_TIMEOUT_MS = 5e3;
+var ERROR_BODY_MAX_BYTES = 65536;
+async function readErrorBody(response, signal) {
+  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 { text: "", received: false };
+  }
+  const decoder = new TextDecoder();
+  let text = "";
+  let received = 0;
+  let interrupted = false;
+  const stop = () => {
+    interrupted = true;
+    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) 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);
+    reader.cancel().catch(() => {
+    });
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+  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();
+  const maxAttempts = retry.watchdog ? Number.MAX_SAFE_INTEGER : retry.maxAttempts;
+  let lastError = null;
+  for (let attempt = 0; attempt <= maxAttempts; attempt++) {
+    if (attempt > 0 && signal?.aborted) throw abortError(signal);
+    const fetchSignal = requestSignal(signal, retry.requestTimeoutMs);
+    let response;
+    try {
+      response = await fetch(url, { ...init, redirect: "manual", signal: fetchSignal });
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      lastError = error instanceof Error ? error.message : String(error);
+      if (attempt >= maxAttempts || budgetExhausted(clock, startMs, retry.totalBudgetMs)) break;
+      const delay2 = boundedDelay(clock, backoffMs(attempt, retry), startMs, retry.totalBudgetMs);
+      logger?.warn("retry network error", {
+        attempt: attempt + 1,
+        delayMs: delay2,
+        error: lastError
+      });
+      onRetry?.(attempt + 1, maxAttempts === Number.MAX_SAFE_INTEGER ? -1 : maxAttempts, delay2);
+      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 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 buffered({
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
+    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 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 buffered({
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
+    const delay = boundedDelay(
+      clock,
+      backoffMs(attempt, retry, stated),
+      startMs,
+      retry.totalBudgetMs
+    );
+    logger?.warn("retry http status", {
+      attempt: attempt + 1,
+      status: response.status,
+      delayMs: delay
+    });
+    onRetry?.(attempt + 1, effectiveMax === Number.MAX_SAFE_INTEGER ? -1 : effectiveMax, delay);
+    try {
+      await sleep(delay, signal);
+    } catch {
+      return buffered({
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
+    await cancelBody(response);
+  }
+  throw new Error(lastError ?? "request failed after retries");
+}
+async function readStreamChunk(reader, signal, stallTimeoutMs) {
+  if (signal?.aborted) return { tag: "abort" };
+  let timeout;
+  let onAbort;
+  try {
+    return await Promise.race([
+      reader.read().then((result) => ({
+        tag: "read",
+        done: result.done,
+        value: result.value
+      })),
+      ...stallTimeoutMs > 0 ? [
+        new Promise((resolve) => {
+          timeout = setTimeout(() => resolve({ tag: "stall" }), stallTimeoutMs);
+        })
+      ] : [],
+      ...signal ? [
+        new Promise((resolve) => {
+          onAbort = () => resolve({ tag: "abort" });
+          signal.addEventListener("abort", onAbort, { once: true });
+        })
+      ] : []
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+  }
+}
+function requestSignal(signal, timeoutMs) {
+  if (timeoutMs <= 0) return signal;
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function abortError(signal) {
+  return signal.reason instanceof Error ? signal.reason : new Error("Aborted");
+}
+function safeErrorDetail(body) {
+  const { message, parsed } = errorBodyParts(body);
+  if (parsed && message) return message.slice(0, 2e3);
+  return body.slice(0, 200);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(abortError(signal));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal ? abortError(signal) : new Error("Aborted"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+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()));
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds > 0) return seconds * 1e3;
+  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 { 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;
+  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;
+}
+function boundedDelay(clock, delayMs, startMs, budgetMs) {
+  if (budgetMs <= 0) return delayMs;
+  return Math.min(delayMs, Math.max(0, budgetMs - (clock.monotonicNowMs() - startMs)));
+}
+
+// src/provider/openai-compatible.ts
+var log = createDebugLogger("provider");
+function parseToolArguments(raw) {
+  if (!raw.trim()) return { arguments: {} };
+  try {
+    const parsed = JSON.parse(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) {
+  for (const key of ["reasoning_content", "reasoning", "thinking", "analysis"]) {
+    const value = delta[key];
+    if (typeof value === "string" && value) return value;
+  }
+  const details = delta.reasoning_details;
+  if (!Array.isArray(details)) return void 0;
+  const text = details.map((detail) => {
+    if (typeof detail === "string") return detail;
+    if (!detail || typeof detail !== "object") return "";
+    const item = detail;
+    for (const key of ["text", "reasoning", "content"]) {
+      if (typeof item[key] === "string") return item[key];
+    }
+    return "";
+  }).filter(Boolean).join("");
+  return text || void 0;
+}
+function isSystemPromptZones(content) {
+  return !!content && typeof content === "object" && "cachedPrefix" in content && "dynamicSuffix" in content;
+}
+function flattenMessages(messages) {
+  return messages.map(({ providerMetadata: _providerMetadata, reasoningContent, ...msg }) => ({
+    ...msg,
+    content: isSystemPromptZones(msg.content) ? [msg.content.cachedPrefix, msg.content.dynamicSuffix].filter(Boolean).join("\n\n") : Array.isArray(msg.content) ? msg.content.map(
+      (part) => part.type === "text" ? part : {
+        type: "image_url",
+        image_url: { url: `data:${part.mediaType};base64,${part.data}` }
+      }
+    ) : 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",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema ?? tool.parameters
+    }
+  }));
+}
+async function* chatCompletionStream(config, messages, tools, options) {
+  const retry = config.retry;
+  const signal = options?.signal;
+  const url = `${config.baseUrl}/chat/completions`;
+  const body = {
+    model: config.model,
+    messages: flattenMessages(messages),
+    stream: true,
+    // Request token usage in the final SSE chunk so we can track cost.
+    stream_options: { include_usage: true }
+  };
+  if (options?.maxOutputTokens || config.maxTokensExplicit || config.modelInfo?.maxOutputTokens) {
+    body.max_tokens = options?.maxOutputTokens ?? config.maxTokens;
+  }
+  if (config.effortExplicit && config.effort) body.reasoning_effort = config.effort;
+  const reasoningEnabled = body.reasoning_effort !== void 0 || typeof config.modelInfo?.effort === "object";
+  if (tools.length > 0) {
+    body.tools = convertTools(tools);
+  }
+  log.debug("chatCompletionStream request", {
+    model: config.model,
+    messageCount: messages.length,
+    toolCount: tools.length,
+    maxTokens: config.maxTokens
+  });
+  let response;
+  try {
+    response = await fetchWithRetry(
+      url,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${config.apiKey}`
+        },
+        body: JSON.stringify(body)
+      },
+      retry,
+      signal,
+      options?.onRetry,
+      log
+    );
+  } catch (e) {
+    if (signal?.aborted) return;
+    log.warn("fetchWithRetry failed", e instanceof Error ? e.message : String(e));
+    yield {
+      type: "error",
+      error: e instanceof Error ? e.message : String(e),
+      errorCode: classifyProviderError(e)
+    };
+    return;
+  }
+  if (signal?.aborted) {
+    await response.body?.cancel();
+    return;
+  }
+  log.debug("response received", { status: response.status, ok: response.ok });
+  if (!response.ok) {
+    const errorBody = await readErrorBody(response, signal);
+    yield statedWaitErrorEvent(response, errorBody.text, {
+      url,
+      model: config.model,
+      bodyReceived: errorBody.received
+    });
+    return;
+  }
+  const reader = response.body?.getReader();
+  if (!reader) {
+    yield { type: "error", error: "No response body", errorCode: "protocol_error" };
+    return;
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const toolCallParts = [];
+  let currentUsage = null;
+  let responseModel;
+  let responseId;
+  const finishReasons = /* @__PURE__ */ new Set();
+  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);
+      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,
+          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: arguments_,
+          ...unparsedArguments ? { unparsedArguments } : {},
+          ...emptyOnWire ? { emptyOnWire: true } : {}
+        }
+      };
+    }
+  };
+  const emitDone = function* (terminal) {
+    yield* emitToolCalls();
+    log.info("stream done", {
+      terminal,
+      promptTokens: currentUsage?.promptTokens ?? 0,
+      completionTokens: currentUsage?.completionTokens ?? 0,
+      totalTokens: currentUsage?.totalTokens ?? 0,
+      cacheReadInputTokens: currentUsage?.cacheReadInputTokens ?? 0,
+      cacheCreationInputTokens: currentUsage?.cacheCreationInputTokens ?? 0
+    });
+    yield {
+      type: "done",
+      usage: currentUsage ?? void 0,
+      ...responseModel ? { responseModel } : {},
+      ...responseId ? { responseId } : {},
+      ...finishReasons.size > 0 ? { finishReasons: [...finishReasons] } : {}
+    };
+  };
+  const processSseLine = function* (line) {
+    const trimmed = line.trim();
+    if (!trimmed || !trimmed.startsWith("data:")) return false;
+    const data = trimmed.slice(5).replace(/^ /, "");
+    if (data === "[DONE]") {
+      yield* emitDone("[DONE]");
+      return true;
+    }
+    try {
+      const parsed = JSON.parse(data);
+      if (typeof parsed.model === "string") responseModel = parsed.model;
+      if (typeof parsed.id === "string") responseId = parsed.id;
+      const usage = parseCompatibleUsage(parsed.usage);
+      if (usage) currentUsage = usage;
+      const choice = parsed.choices?.[0];
+      if (!choice) return false;
+      const finishReason = choice.finish_reason;
+      if (typeof finishReason === "string" && finishReason) finishReasons.add(finishReason);
+      const delta = choice.delta;
+      if (!delta) return false;
+      const reasoning = parseReasoningDelta(delta);
+      if (reasoning) {
+        stallTimeoutMs = retry.thinkingStallTimeoutMs ? Math.max(startingStallTimeoutMs, retry.thinkingStallTimeoutMs) : startingStallTimeoutMs;
+        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) {
+        stallTimeoutMs = startingStallTimeoutMs;
+        for (const tc of delta.tool_calls) {
+          const explicitIndex = Number.isInteger(tc.index) ? tc.index : void 0;
+          let index = explicitIndex;
+          if (index === void 0 && tc.id) {
+            index = toolCallParts.find((part2) => part2.id === tc.id)?.index;
+          }
+          if (index === void 0) {
+            index = toolCallParts.length;
+          }
+          let part = toolCallParts.find((p) => p.index === index);
+          if (!part) {
+            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) {
+            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 startingStallTimeoutMs = reasoningEnabled && retry.thinkingStallTimeoutMs ? Math.max(retry.streamStallTimeoutMs, retry.thinkingStallTimeoutMs) : retry.streamStallTimeoutMs;
+  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);
+      if (result.tag === "abort") {
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        return;
+      }
+      if (result.tag === "stall") {
+        log.warn("stream stalled", { timeoutMs: stallTimeoutMs });
+        options?.onStreamStall?.(stallTimeoutMs);
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        yield {
+          type: "error",
+          error: "Stream stalled: no data received for " + stallTimeoutMs + "ms",
+          errorCode: "stream_stall"
+        };
+        return;
+      }
+      if (result.done) break;
+      const value = result.value;
+      if (!value) continue;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (yield* processSseLine(line)) return;
+      }
+    }
+    buffer += decoder.decode();
+    for (const line of buffer.split("\n")) {
+      if (yield* processSseLine(line)) return;
+    }
+    if (finishReasons.size > 0) {
+      yield* emitDone("finish_reason");
+      return;
+    }
+  } catch (e) {
+    if (signal?.aborted) return;
+    yield {
+      type: "error",
+      error: e instanceof Error ? e.message : String(e),
+      errorCode: classifyProviderError(e)
+    };
+    return;
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+  yield {
+    type: "error",
+    error: "Provider stream ended before its terminal event.",
+    errorCode: "transport_interrupted"
+  };
+}
+
+export {
+  classifyProviderError,
+  isContextOverflowError,
+  isOversizedForRateLimit,
+  statedRateLimit,
+  isErrorEnvelopeShape,
+  isUpstreamErrorEnvelope,
+  readErrorBody,
+  isRedirectResponse,
+  refuseRedirect,
+  fetchWithRetry,
+  readStreamChunk,
+  statedWaitErrorEvent,
+  parseCompatibleUsage,
+  convertTools,
+  chatCompletionStream
+};
+//# sourceMappingURL=chunk-AHC7OU75.js.map