@letrquan/book 0.2.0

package/dist/chunk-GTVB4HEM.js

@@ -0,0 +1,765 @@
+import {
+  systemClock
+} from "./chunk-7N4J557C.js";
+
+// src/debug-log.ts
+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)
+  );
+}
+function rotateDebugLog(target, incomingBytes) {
+  if (!existsSync(target)) {
+    debugLogSizes.set(target, 0);
+    return;
+  }
+  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;
+  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++;
+    }
+  } 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;
+    }
+    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 {
+      try {
+        repr = JSON.stringify(value);
+      } catch {
+        repr = String(value);
+      }
+    }
+    parts.push(`${key}=${repr}`);
+  }
+  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) {
+  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}
+`);
+    }
+  };
+}
+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 classifyApiError(status, body) {
+  const code = classifyHttpStatus(status).code;
+  return code === "bad_request" && isContextOverflowError(body) ? "context_overflow" : code;
+}
+function classifyProviderError(error) {
+  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);
+  const detail = safeErrorDetail(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 `${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":
+      return `${base} ${detail}. 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.`;
+    case "quota":
+      return `${base} ${detail}. Check your usage/credits.`;
+    default:
+      return `${base} ${detail}`;
+  }
+}
+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(
+    normalized
+  ) || /too\s+many\s+(?:input\s+)?tokens|request\s+too\s+large.*token/.test(normalized);
+}
+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, 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 > 100 ? -1 : maxAttempts, delay2);
+      await sleep(delay2, signal);
+      continue;
+    }
+    const classification = classifyHttpStatus(response.status);
+    if (!classification.retryable) return response;
+    lastError = `API error ${response.status}`;
+    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;
+    const delay = boundedDelay(
+      clock,
+      backoffMs(attempt, retry, response.headers.get("retry-after")),
+      startMs,
+      retry.totalBudgetMs
+    );
+    logger?.warn("retry http status", {
+      attempt: attempt + 1,
+      status: response.status,
+      delayMs: delay
+    });
+    onRetry?.(attempt + 1, watchdogRetry ? -1 : maxAttempts, delay);
+    try {
+      await sleep(delay, signal);
+    } catch {
+      return response;
+    }
+    try {
+      await response.body?.cancel();
+    } catch {
+    }
+  }
+  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) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed.error?.message === "string") return parsed.error.message.slice(0, 2e3);
+  } catch {
+  }
+  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 });
+  });
+}
+function backoffMs(attempt, retry, retryAfter) {
+  const retryAfterMs = parseRetryAfter(retryAfter);
+  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()));
+}
+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());
+}
+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 {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return { __raw: raw };
+  }
+}
+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 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 errorText = await response.text();
+    yield {
+      type: "error",
+      error: formatApiError(response.status, errorText),
+      errorCode: classifyApiError(response.status, errorText)
+    };
+    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;
+      yield {
+        type: "tool_call",
+        toolCall: {
+          id: part.id || `tool-${part.index}`,
+          name: part.name,
+          arguments: parseToolArguments(part.arguments)
+        }
+      };
+    }
+  };
+  const emitDone = function* (terminal) {
+    yield* emitToolCalls();
+    log.info("stream done", {
+      terminal,
+      promptTokens: currentUsage?.promptTokens ?? 0,
+      completionTokens: currentUsage?.completionTokens ?? 0,
+      totalTokens: currentUsage?.totalTokens ?? 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;
+      if (parsed.usage) {
+        currentUsage = {
+          promptTokens: parsed.usage.prompt_tokens ?? 0,
+          completionTokens: parsed.usage.completion_tokens ?? 0,
+          totalTokens: parsed.usage.total_tokens ?? 0
+        };
+      }
+      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) {
+        log.debug("stream reasoning", { len: reasoning.length });
+        yield { type: "reasoning", reasoning };
+      }
+      if (delta.content) {
+        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 });
+        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: "" };
+            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;
+        }
+      }
+    } catch {
+    }
+    return false;
+  };
+  const stallTimeoutMs = reasoningEnabled && retry.thinkingStallTimeoutMs ? Math.max(retry.streamStallTimeoutMs, retry.thinkingStallTimeoutMs) : retry.streamStallTimeoutMs;
+  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 {
+  DEFAULT_LOCAL_DATA_RETENTION_DAYS,
+  positiveInteger,
+  getDebugLogPath,
+  cleanupDebugLogs,
+  isUiDebugEnabled,
+  isRenderDebugEnabled,
+  createDebugLogger,
+  createDebugLoggerWithCounter,
+  createUiDebugLogger,
+  createRenderDebugLogger,
+  classifyApiError,
+  classifyProviderError,
+  formatApiError,
+  isContextOverflowError,
+  fetchWithRetry,
+  readStreamChunk,
+  convertTools,
+  chatCompletionStream
+};
+//# sourceMappingURL=chunk-GTVB4HEM.js.map