tianshu-harness 3.23.0

package/dist/chunk-X2IK5LVR.js

@@ -0,0 +1,2592 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  sanitizeMessageContent
+} from "./chunk-CEZNQVWM.js";
+import {
+  require_undici
+} from "./chunk-O5VZQKCB.js";
+import {
+  abortableDelay,
+  getProviderProfile,
+  withStructuredRetry
+} from "./chunk-ZQKXBUB7.js";
+import {
+  parseJsonObjectWithEscapeRepair,
+  repairInvalidJsonEscapes
+} from "./chunk-Z5Z3JHJY.js";
+import {
+  estimateOaiTokens
+} from "./chunk-KIOXTQQL.js";
+import {
+  debugLog
+} from "./chunk-CI4R6P2B.js";
+import {
+  normalizeOaiMessage,
+  oaiMessagesHaveImageParts,
+  stripOaiImageParts
+} from "./chunk-EXXICUIW.js";
+import {
+  stableStringify
+} from "./chunk-QARAGUXX.js";
+import {
+  contractModels,
+  isKeylessProviderEntry,
+  normalizeBaseUrl,
+  proRegistry,
+  readSecret
+} from "./chunk-ER5JW2QZ.js";
+import {
+  ReasoningRepetitionGuard,
+  fetchCauseDetail,
+  parseRetryAfterMs
+} from "./chunk-BKTQAYO2.js";
+import {
+  external_exports
+} from "./chunk-OO3TAHO5.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/api/provider.ts
+init_esm_shims();
+function mapDeepSeekUsage(raw) {
+  return {
+    // Support both DeepSeek native format and Anthropic compatibility format
+    input_tokens: raw.prompt_tokens ?? raw.input_tokens ?? 0,
+    output_tokens: raw.completion_tokens ?? raw.output_tokens ?? 0,
+    cache_read_input_tokens: raw.prompt_cache_hit_tokens ?? raw.cache_read_input_tokens ?? raw.prompt_tokens_details?.cached_tokens ?? 0,
+    cache_creation_input_tokens: raw.prompt_cache_miss_tokens ?? raw.cache_creation_input_tokens ?? 0
+  };
+}
+var DEEPSEEK_CAPABILITIES = {
+  supportsThinking: true,
+  thinkingBlockType: "enabled",
+  preservedThinkingProtocol: true,
+  supportsCacheControl: false,
+  stripParams: ["top_k", "metadata", "service_tier", "cache_control"],
+  hasToolJsonInContentBug: true,
+  effortFormat: "reasoning_effort",
+  prefixCacheStrategy: "deepseek-native",
+  supportsResponseFormat: true,
+  mapUsage: mapDeepSeekUsage
+};
+var DEFAULT_CAPABILITIES = {
+  supportsThinking: false,
+  thinkingBlockType: "none",
+  supportsCacheControl: true,
+  stripParams: [],
+  hasToolJsonInContentBug: false,
+  effortFormat: "none",
+  prefixCacheStrategy: "none",
+  supportsResponseFormat: false
+};
+var WELL_KNOWN_DEFAULTS = {
+  deepseek: DEEPSEEK_CAPABILITIES,
+  kimi: {
+    supportsThinking: true,
+    thinkingBlockType: "enabled",
+    // 无 effortCap：官方 Kimi Code 文档（kimi-code/models.html）——k3 / k3-256k
+    // 的 reasoning_effort 支持 low|high|max，第三方工具传 max 即映射到 max。
+    // 旧值 {max:'high'} 会把用户显式选的 max 静默降成 high，K3 旗舰的 max 档
+    // 永远发不出去。K2.7 Code（kimi-for-coding）是 Thinking:ON、无档位。
+    supportsCacheControl: false,
+    stripParams: ["top_k", "metadata", "service_tier", "cache_control"],
+    hasToolJsonInContentBug: false,
+    effortFormat: "reasoning_effort",
+    prefixCacheStrategy: "none",
+    supportsResponseFormat: false
+  },
+  glm: {
+    supportsThinking: true,
+    thinkingBlockType: "enabled",
+    supportsCacheControl: false,
+    stripParams: ["top_k", "metadata", "service_tier"],
+    hasToolJsonInContentBug: false,
+    effortFormat: "reasoning_effort",
+    // GLM-5.2 has implicit exact-prefix caching (no cache_control breakpoints),
+    // reported via usage.prompt_tokens_details.cached_tokens — same model as DeepSeek.
+    prefixCacheStrategy: "deepseek-native",
+    supportsResponseFormat: true,
+    mapUsage: mapDeepSeekUsage
+  },
+  minimax: {
+    supportsThinking: true,
+    thinkingBlockType: "adaptive",
+    reasoningSplit: true,
+    supportsCacheControl: false,
+    stripParams: ["top_k", "metadata", "service_tier", "cache_control"],
+    hasToolJsonInContentBug: false,
+    effortFormat: "none",
+    prefixCacheStrategy: "none",
+    supportsResponseFormat: false
+  },
+  mimo: {
+    supportsThinking: true,
+    thinkingBlockType: "enabled",
+    preservedThinkingProtocol: true,
+    supportsCacheControl: false,
+    stripParams: ["top_k", "metadata", "service_tier", "cache_control"],
+    hasToolJsonInContentBug: false,
+    effortFormat: "none",
+    prefixCacheStrategy: "none",
+    supportsResponseFormat: false
+  },
+  "mimo-api": {
+    supportsThinking: true,
+    thinkingBlockType: "enabled",
+    supportsCacheControl: false,
+    stripParams: ["top_k", "metadata", "service_tier", "cache_control"],
+    hasToolJsonInContentBug: false,
+    effortFormat: "none",
+    prefixCacheStrategy: "deepseek-native",
+    supportsResponseFormat: false
+  },
+  "opencode-go": {
+    // 推理透传：上游不认 thinking 块（默认就返回 reasoning_content），但接受
+    // reasoning_effort——low/medium/high/max/xhigh 实测全部 200。曾配成
+    // effortFormat 'none'，而 openai-client 的两个分支都以 effortFormat !== 'none'
+    // 为写入前提（openai-client.ts:518-548），于是用户的档位选择被静默吞掉。
+    // 透传后是否按档位调节由上游决定；天枢的职责是别把它丢掉。
+    supportsThinking: true,
+    thinkingBlockType: "none",
+    supportsCacheControl: false,
+    stripParams: ["top_k", "metadata", "service_tier", "cache_control"],
+    hasToolJsonInContentBug: false,
+    effortFormat: "reasoning_effort",
+    prefixCacheStrategy: "none",
+    supportsResponseFormat: false
+  },
+  openai: {
+    supportsThinking: true,
+    thinkingBlockType: "none",
+    supportsCacheControl: true,
+    stripParams: [],
+    hasToolJsonInContentBug: false,
+    effortFormat: "reasoning_effort",
+    prefixCacheStrategy: "none",
+    supportsResponseFormat: true
+  },
+  codex: {
+    supportsThinking: true,
+    thinkingBlockType: "none",
+    effortCap: { max: "xhigh" },
+    supportsCacheControl: true,
+    stripParams: [],
+    hasToolJsonInContentBug: false,
+    effortFormat: "reasoning_effort",
+    prefixCacheStrategy: "none",
+    supportsResponseFormat: true
+  },
+  claude: {
+    supportsThinking: true,
+    thinkingBlockType: "enabled",
+    thinkingBudgetField: "budget_tokens",
+    supportsCacheControl: false,
+    stripParams: ["top_k", "metadata", "service_tier"],
+    hasToolJsonInContentBug: false,
+    effortFormat: "reasoning_effort",
+    prefixCacheStrategy: "none",
+    supportsResponseFormat: false
+  },
+  // LongCat official docs support ONLY model/messages/stream/max_tokens/
+  // temperature/top_p — no response_format (json-mode repair unusable, worker
+  // repair must run as plain-text re-ask) and no cache_control breakpoints
+  // (server-side implicit prefix caching, hits free). Explicit entry so
+  // behavior doesn't ride on the DEFAULT_CAPABILITIES fallback
+  // (session 2c1186f5 scout postmortem).
+  longcat: {
+    supportsThinking: false,
+    thinkingBlockType: "none",
+    supportsCacheControl: false,
+    stripParams: ["top_k", "metadata", "service_tier", "cache_control"],
+    hasToolJsonInContentBug: false,
+    effortFormat: "none",
+    prefixCacheStrategy: "deepseek-native",
+    supportsResponseFormat: false,
+    mapUsage: mapDeepSeekUsage
+  },
+  ccswitch: {
+    // cc-switch 是 OpenAI 兼容代理，入口层透传 reasoning_effort；
+    // 其 Rectifier 翻译层会将 OpenAI 格式转为 Claude/DeepSeek 等上游原生格式。
+    // 后端模型不认识 reasoning_effort 时按 OpenAI 兼容约定静默忽略（降级）。
+    supportsThinking: true,
+    thinkingBlockType: "none",
+    supportsCacheControl: false,
+    stripParams: ["top_k", "metadata", "service_tier", "cache_control"],
+    hasToolJsonInContentBug: false,
+    effortFormat: "reasoning_effort",
+    prefixCacheStrategy: "none",
+    supportsResponseFormat: false
+  },
+  // ── Aggregator / relay providers ─────────────────────────────────────────
+  // SiliconFlow aggregator (硅基流动). Default model in preset is DeepSeek-proxied
+  // → toolJsonBug:true set in preset overrides. Server-side implicit prefix caching
+  // on DeepSeek-V4 / GLM-5.2 (charges for cached input) → deepseek-native strategy
+  // to preserve cache-aware compaction.
+  siliconflow: {
+    supportsThinking: true,
+    thinkingBlockType: "enabled",
+    supportsCacheControl: false,
+    stripParams: ["top_k", "metadata", "service_tier", "cache_control"],
+    hasToolJsonInContentBug: false,
+    effortFormat: "reasoning_effort",
+    prefixCacheStrategy: "deepseek-native",
+    supportsResponseFormat: false,
+    mapUsage: mapDeepSeekUsage
+  },
+  // DashScope (阿里通义千问官方 OpenAI 兼容端点). Qwen3-max supports thinking
+  // block; Qwen-plus/turbo do not — per-model override via `models[].capabilities`.
+  // DashScope OpenAI-compatible endpoint does not accept cache_control breakpoints
+  // (that's Anthropic protocol); cache profile is 'explicit-breakpoint' only via
+  // the legacy PROFILES['qwen'] entry kept for back-compat.
+  dashscope: {
+    supportsThinking: true,
+    thinkingBlockType: "enabled",
+    supportsCacheControl: false,
+    stripParams: ["top_k", "metadata", "service_tier", "cache_control"],
+    hasToolJsonInContentBug: false,
+    effortFormat: "reasoning_effort",
+    prefixCacheStrategy: "none",
+    supportsResponseFormat: true
+  },
+  // OpenRouter international aggregator. thinking block passthrough is unstable
+  // across the model fleet → thinkingBlockType:'none', rely on reasoning_effort
+  // passthrough only. Users can override per-model via `models[].capabilities`.
+  openrouter: {
+    supportsThinking: true,
+    thinkingBlockType: "none",
+    supportsCacheControl: false,
+    stripParams: ["top_k", "metadata", "service_tier", "cache_control"],
+    hasToolJsonInContentBug: false,
+    effortFormat: "reasoning_effort",
+    prefixCacheStrategy: "none",
+    supportsResponseFormat: false
+  },
+  // one-api / new-api self-hosted relay (generic template, not activated by
+  // default to avoid overlap with ccswitch). Same shape as ccswitch — relay
+  // entry point passes reasoning_effort through, upstream Rectifier translates.
+  relay: {
+    supportsThinking: true,
+    thinkingBlockType: "none",
+    supportsCacheControl: false,
+    stripParams: ["top_k", "metadata", "service_tier", "cache_control"],
+    hasToolJsonInContentBug: false,
+    effortFormat: "reasoning_effort",
+    prefixCacheStrategy: "none",
+    supportsResponseFormat: false
+  }
+};
+function applyOverrides(base, overrides) {
+  if (!overrides) return base;
+  if (overrides.cacheControl !== void 0) base.supportsCacheControl = overrides.cacheControl;
+  if (overrides.stripParams !== void 0 && overrides.stripParams.length > 0) base.stripParams = overrides.stripParams;
+  if (overrides.toolJsonBug !== void 0) base.hasToolJsonInContentBug = overrides.toolJsonBug;
+  if (overrides.prefixCache !== void 0) base.prefixCacheStrategy = overrides.prefixCache;
+  if (overrides.thinkingBlock !== void 0) base.thinkingBlockType = overrides.thinkingBlock;
+  if (overrides.effortFormat !== void 0) base.effortFormat = overrides.effortFormat;
+  if (overrides.effortCap !== void 0) base.effortCap = { ...overrides.effortCap };
+  if (overrides.reasoningSplit !== void 0) base.reasoningSplit = overrides.reasoningSplit;
+  if (overrides.thinkingBudgetField !== void 0) base.thinkingBudgetField = overrides.thinkingBudgetField;
+  if (overrides.preservedThinkingProtocol !== void 0) base.preservedThinkingProtocol = overrides.preservedThinkingProtocol;
+  const declaresThinking = overrides.thinkingBlock === "enabled" || overrides.thinkingBlock === "adaptive" || overrides.effortFormat === "reasoning_effort" || overrides.effortFormat === "output_config";
+  const declaresNoThinking = overrides.thinkingBlock === "none" && overrides.effortFormat === "none";
+  if (declaresThinking) base.supportsThinking = true;
+  else if (declaresNoThinking) base.supportsThinking = false;
+  return base;
+}
+function resolveCapabilities(providerName, providerOverrides, modelOverrides) {
+  const base = {
+    ...WELL_KNOWN_DEFAULTS[providerName] ?? DEFAULT_CAPABILITIES
+  };
+  applyOverrides(base, providerOverrides);
+  applyOverrides(base, modelOverrides);
+  return base;
+}
+
+// src/api/factory.ts
+init_esm_shims();
+
+// src/api/openai-client.ts
+init_esm_shims();
+
+// src/api/fetch-timeout.ts
+init_esm_shims();
+var DEFAULT_TIMEOUT_MS = 45e3;
+async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_TIMEOUT_MS, dispatcher) {
+  const userSignal = init.signal;
+  const timeoutController = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    timeoutController.abort();
+  }, timeoutMs);
+  const combinedSignal = userSignal ? AbortSignal.any([userSignal, timeoutController.signal]) : timeoutController.signal;
+  try {
+    const redirect = init.redirect ?? "error";
+    return await fetch(url, { ...init, redirect, signal: combinedSignal, ...dispatcher ? { dispatcher } : {} });
+  } catch (err) {
+    const name = err.name;
+    if (timedOut || name === "TimeoutError") {
+      throw new Error(
+        `Request timed out: server did not respond within ${Math.round(timeoutMs / 1e3)} seconds`
+      );
+    }
+    if (name === "AbortError" || userSignal?.aborted) throw err;
+    if (err instanceof Error && /fetch failed/i.test(err.message)) {
+      const detail = fetchCauseDetail(err);
+      if (detail) throw new Error(`${err.message}: ${detail}`, { cause: err });
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/api/abort-reader.ts
+init_esm_shims();
+function wireAbortToReaderCancel(signal, reader) {
+  const onAbort = () => reader.cancel().catch(() => {
+  });
+  if (signal.aborted) {
+    reader.cancel().catch(() => {
+    });
+    return () => {
+    };
+  }
+  signal.addEventListener("abort", onAbort, { once: true });
+  return () => signal.removeEventListener("abort", onAbort);
+}
+function wrapBodyTimeoutError(err, provider, streamStartedAt) {
+  const name = err?.name;
+  if (name !== "TimeoutError") return err;
+  const secs = Math.round((Date.now() - streamStartedAt) / 1e3);
+  return new Error(
+    `${provider} SSE stream timed out mid-body after ${secs}s of streaming \u2014 a timeout signal aborted the request while the body was still being read`
+  );
+}
+
+// src/api/openai-client.ts
+var import_undici = __toESM(require_undici(), 1);
+import { appendFileSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+
+// src/api/rate-limiter.ts
+init_esm_shims();
+var TokenBucket = class {
+  intervalMs;
+  burst;
+  nextSlotAt;
+  constructor(config) {
+    this.intervalMs = 1e3 / config.requestsPerSecond;
+    this.burst = config.burst ?? Math.max(1, Math.ceil(config.requestsPerSecond));
+    this.nextSlotAt = Date.now() - (this.burst - 1) * this.intervalMs;
+  }
+  async acquire(signal) {
+    if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+    const now = Date.now();
+    const earliest = now - (this.burst - 1) * this.intervalMs;
+    const slot = Math.max(earliest, this.nextSlotAt);
+    this.nextSlotAt = slot + this.intervalMs;
+    const waitMs = Math.ceil(slot - now);
+    if (waitMs <= 0) return;
+    await abortableDelay(waitMs, signal);
+  }
+};
+var registry = /* @__PURE__ */ new Map();
+function getProviderRateLimiter(providerKey, config) {
+  if (!config || !(config.requestsPerSecond > 0)) return void 0;
+  const fingerprint = `${config.requestsPerSecond}:${config.burst ?? ""}`;
+  const existing = registry.get(providerKey);
+  if (existing && existing.fingerprint === fingerprint) return existing.limiter;
+  const limiter = new TokenBucket(config);
+  registry.set(providerKey, { fingerprint, limiter });
+  return limiter;
+}
+async function acquireRateLimitSlot(providerKey, config, signal) {
+  const limiter = getProviderRateLimiter(providerKey, config);
+  if (limiter) await limiter.acquire(signal);
+}
+
+// src/api/openai-client.ts
+function wireHash(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) {
+    h = (h << 5) + h + s.charCodeAt(i) | 0;
+  }
+  return `${h}:${s.length}`;
+}
+function tryParseToolArguments(raw) {
+  if (raw.trim().length === 0) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    const repaired = repairInvalidJsonEscapes(raw);
+    if (repaired !== null) {
+      try {
+        const parsed = JSON.parse(repaired);
+        if (parsed && typeof parsed === "object") return parsed;
+      } catch {
+      }
+    }
+    return salvageFirstJsonObject(repaired ?? raw);
+  }
+}
+function salvageFirstJsonObject(raw) {
+  const start = raw.indexOf("{");
+  if (start === -1) return null;
+  let depth = 0;
+  let inStr = false;
+  let escaped = false;
+  for (let i = start; i < raw.length; i++) {
+    const ch = raw[i];
+    if (inStr) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inStr = false;
+      continue;
+    }
+    if (ch === '"') inStr = true;
+    else if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        try {
+          const obj = JSON.parse(raw.slice(start, i + 1));
+          return obj && typeof obj === "object" ? obj : null;
+        } catch {
+          return null;
+        }
+      }
+    }
+  }
+  return null;
+}
+var FIRST_BYTE_TIMEOUT_MS = 45e3;
+var REASONING_FIRST_BYTE_TIMEOUT_MS = 9e4;
+var READ_TIMEOUT_MS = 12e4;
+var REASONING_READ_TIMEOUT_MS = 18e4;
+var SLOW_FIRST_BYTE_TIMEOUT_MS = 18e4;
+var SLOW_READ_TIMEOUT_MS = 3e5;
+var FIRST_BYTE_PER_100K_MS = 6e4;
+var FIRST_BYTE_MAX_MS = 42e4;
+var GLM_READ_TIMEOUT_MS = 72e4;
+var SLOW_THINKING_PROVIDERS = /* @__PURE__ */ new Set(["glm", "mimo", "deepseek", "codex", "minimax"]);
+var SLOW_THINKING_HOST_HINTS = ["deepseek", "bigmodel.cn", "xiaomimimo", "minimax", "chatgpt.com"];
+function isSlowThinkingProvider(input) {
+  if (input.slowThinking !== void 0) return input.slowThinking;
+  if (SLOW_THINKING_PROVIDERS.has(input.providerName ?? "")) return true;
+  if (input.baseUrl) {
+    try {
+      const host = new URL(input.baseUrl).hostname.toLowerCase();
+      return SLOW_THINKING_HOST_HINTS.some((hint) => host.includes(hint));
+    } catch {
+    }
+  }
+  return false;
+}
+var TOOL_STREAM_LOG_MAX_LINES = 2e3;
+function redactSensitiveArgs(fragment) {
+  return fragment.replace(
+    /("(?:[^"\\]*(?:password|passwd|secret|token|api[_-]?key|apikey|authorization|credential|private[_-]?key|access[_-]?key)[^"\\]*)"\s*:\s*")((?:[^"\\]|\\.)*)("?)/gi,
+    "$1[REDACTED]$3"
+  );
+}
+var HARD_CAP_PROGRESS_WINDOW_MS = 6e4;
+var HARD_CAP_EXTENSION_SLICE_MS = 6e4;
+var GLM_HARD_CAP_PROGRESS_WINDOW_MS = 12e4;
+function computeFirstByteTimeoutMs(input) {
+  const per100kMs = input.per100kMs ?? FIRST_BYTE_PER_100K_MS;
+  const capMs = input.capMs ?? FIRST_BYTE_MAX_MS;
+  const buckets = Math.floor(Math.max(0, input.estInputTokens) / 1e5);
+  const scaled = input.baseMs + buckets * per100kMs;
+  return Math.min(scaled, capMs);
+}
+function decideStreamHardCap(input, progressWindowMs = HARD_CAP_PROGRESS_WINDOW_MS) {
+  const absoluteMaxMs = input.baseStreamMs * 3;
+  const elapsed = input.now - input.startedAt;
+  if (elapsed >= absoluteMaxMs) return { kind: "abort" };
+  if (elapsed >= input.baseStreamMs) {
+    if (input.now - input.lastDataEventAt > progressWindowMs) return { kind: "abort" };
+    return { kind: "rearm", rearmMs: Math.min(HARD_CAP_EXTENSION_SLICE_MS, absoluteMaxMs - elapsed), extended: true };
+  }
+  return { kind: "rearm", rearmMs: input.baseStreamMs - elapsed, extended: false };
+}
+var OpenAIClient = class {
+  constructor(config) {
+    this.config = config;
+    this.systemSuffix = Boolean(config.preservedThinkingProtocol) && config.thinking === "enabled" ? "\n\n\u8BF7\u5728\u5185\u90E8\u601D\u8003\u94FE\u4E2D\u4F7F\u7528\u4E2D\u6587\u8FDB\u884C\u63A8\u7406\u3002\u4E0D\u8981\u5728\u56DE\u590D\u4E2D\u8F93\u51FA\u4F60\u7684\u63A8\u7406\u8FC7\u7A0B\uFF0C\u53EA\u8F93\u51FA\u6700\u7EC8\u7B54\u6848\u6216\u5DE5\u5177\u8C03\u7528\u3002" : "";
+    this._sanitizedCount = 0;
+    this.proxyDispatcher = config.proxy ? new import_undici.ProxyAgent(config.proxy) : void 0;
+  }
+  config;
+  toolCallBuffer = /* @__PURE__ */ new Map();
+  toolCallHintFired = /* @__PURE__ */ new Set();
+  /** Resolved raw-SSE dump path (undefined = unresolved, null = disabled/failed). */
+  rawSsePath = void 0;
+  pendingStopReason = null;
+  /** Messages from the current stream request — used for usage calibration. */
+  lastRequestMessages = [];
+  /** Accumulated text for DeepSeek tool-JSON-in-content fallback (网#1). */
+  _textAccum = "";
+  /** Whether any content delta has started this stream (channel monotonicity:
+   *  reasoning_content arriving after content is a protocol anomaly, reclassified as text). */
+  contentStarted = false;
+  /** Stable suffix appended to system message for Chinese thinking (computed once, cache-safe). */
+  systemSuffix;
+  /**
+   * Resolved path for the lightweight tool-stream event log (always-on, best-effort).
+   * undefined = unresolved, null = disabled/failed. Appends one JSON line per
+   * notable streaming event (pollution-risk drops, final-flush empties) so the
+   * cross-tool argument corruption class of bug leaves a trace WITHOUT requiring
+   * RIVET_DEBUG. Capped at TOOL_STREAM_LOG_MAX_LINES per process to bound disk.
+   */
+  toolStreamLogPath = void 0;
+  toolStreamLogLines = 0;
+  /** Wire-level prefix probe: per-message signatures of the previous main-turn
+   *  request's FINAL bytes (post reasoning-strip / sanitize / system-suffix).
+   *  Only updated for requests with `prefixProbe: true` so side-path calls
+   *  through this client don't poison the baseline. */
+  prevWireSignatures = null;
+  /** 上一次主轮请求的 tools 数组指纹（同序 stable-json——上线字节保数组序）。
+   *  消息级探针对工具定义变化隐形（2026-09-06 主会话 toolsUpdated 碎裂事件
+   *  双探针皆净即此因），单独一个维度。 */
+  prevWireToolsSig = null;
+  /** Latest wire divergence (consume-once via consumeWireDivergence). */
+  lastWireDivergence = null;
+  /** undici ProxyAgent for config.proxy (undefined = no per-provider proxy). */
+  proxyDispatcher;
+  /** 慢思考端点判定（名称/URL/显式配置三级，见 isSlowThinkingProvider）。 */
+  get isSlowThinking() {
+    return isSlowThinkingProvider({
+      providerName: this.config.providerName,
+      baseUrl: this.config.baseUrl,
+      slowThinking: this.config.slowThinking
+    });
+  }
+  // ── Incremental sanitize ─────────────────────────────────────
+  // Historical messages are already sanitized at entry points
+  // (addUserMessage/addAssistantBlocks/addToolResults). Re-sanitizing
+  // the full message array every turn is O(history) overhead that grows
+  // linearly with conversation length — particularly wasteful at 1M
+  // context windows. We track the sanitized count and only apply the
+  // safety-net sanitize to newly appended messages.
+  _sanitizedCount;
+  setReasoningEffort(effort) {
+    this.config = { ...this.config, reasoningEffort: effort };
+  }
+  setThinking(mode) {
+    this.config = { ...this.config, thinking: mode };
+  }
+  async stream(request, callbacks, signal) {
+    this.lastRequestMessages = request.messages;
+    const isPreservedThinking = this.config.thinking === "enabled" && Boolean(this.config.preservedThinkingProtocol);
+    const messages = request.messages.map((m) => {
+      if (m.role !== "assistant") return m;
+      const hasToolCalls = Array.isArray(m.tool_calls) && m.tool_calls.length > 0;
+      if (isPreservedThinking && hasToolCalls && !("reasoning_content" in m)) {
+        return { ...m, reasoning_content: "" };
+      }
+      if (!("reasoning_content" in m)) return m;
+      if (isPreservedThinking && hasToolCalls) {
+        const transform = proRegistry.getWireTransform(this.config.providerName ?? "");
+        if (transform) return transform(m, this.config.model, this.config.wireContext);
+        return m;
+      }
+      const { reasoning_content: _, ...rest } = m;
+      if (!("content" in rest) && !hasToolCalls) {
+        rest.content = "";
+      }
+      return rest;
+    }).map(normalizeOaiMessage);
+    const body = {
+      // 空 model 回退到 client 绑定值——侧路调用（essence-gate / vision bridge）
+      // 传 model: '' 期望"client already binds the model"；不回退会被 provider 400。
+      model: request.model || this.config.model,
+      messages,
+      stream: true
+    };
+    if (this.config.useMaxCompletionTokens) {
+      body.max_completion_tokens = request.max_tokens ?? this.config.maxTokens;
+    } else {
+      body.max_tokens = request.max_tokens ?? this.config.maxTokens;
+    }
+    if (!this.config.unsupported?.includes("stream_options")) {
+      body.stream_options = { include_usage: true };
+    }
+    if (request.tools && request.tools.length > 0) {
+      body.tools = request.tools;
+      if (request.tool_choice) body.tool_choice = request.tool_choice;
+    }
+    if (request.response_format) {
+      body.response_format = request.response_format;
+    } else if (this.config.jsonMode) {
+      body.response_format = { type: "json_object" };
+    }
+    if (request.temperature !== void 0) {
+      body.temperature = request.temperature;
+    } else if (this.config.temperature !== void 0 && this.config.thinking !== "enabled") {
+      body.temperature = this.config.temperature;
+    }
+    if (this.config.reasoningSplit) {
+      body.reasoning_split = true;
+    }
+    const blockType = this.config.thinkingBlockType ?? "none";
+    if (this.config.thinking === "enabled") {
+      if (blockType !== "none") {
+        body.thinking = { type: blockType };
+        if (this.config.thinkingBudgetField === "budget_tokens" && this.config.reasoningEffort) {
+          const budgetMap = {
+            max: this.config.maxTokens,
+            high: Math.floor(this.config.maxTokens * 0.6),
+            medium: Math.floor(this.config.maxTokens * 0.3),
+            low: 8192,
+            off: 0
+          };
+          const budget = budgetMap[this.config.reasoningEffort ?? "high"] ?? Math.floor(this.config.maxTokens * 0.6);
+          body.thinking["budget_tokens"] = budget;
+        }
+        if (this.config.effortFormat === "reasoning_effort" && this.config.reasoningEffort && this.config.reasoningEffort !== "off") {
+          body.reasoning_effort = this.config.reasoningEffort;
+        }
+      } else if (this.config.effortFormat !== "none") {
+        body.reasoning_effort = this.config.reasoningEffort ?? "medium";
+      }
+    }
+    if (request.reasoning_effort && this.config.effortFormat !== "none") {
+      body.reasoning_effort = request.reasoning_effort;
+    }
+    if (this.config.effortCap && typeof body.reasoning_effort === "string") {
+      const capped = this.config.effortCap[body.reasoning_effort];
+      if (capped) body.reasoning_effort = capped;
+    }
+    if (this.systemSuffix) {
+      const wireMessages = body.messages;
+      const sysIdx = wireMessages.findIndex((m) => m.role === "system");
+      const sysMsg = sysIdx >= 0 ? wireMessages[sysIdx] : void 0;
+      if (sysMsg && typeof sysMsg.content === "string") {
+        wireMessages[sysIdx] = { ...sysMsg, content: sysMsg.content + this.systemSuffix };
+      }
+    }
+    const msgArray = body.messages;
+    if (msgArray.length <= this._sanitizedCount) {
+      this._sanitizedCount = 0;
+    }
+    const newMessages = msgArray.slice(this._sanitizedCount);
+    if (newMessages.length > 0) {
+      const sanitizedNew = sanitizeMessageContent(newMessages);
+      for (let i = 0; i < sanitizedNew.length; i++) {
+        msgArray[this._sanitizedCount + i] = sanitizedNew[i];
+      }
+      this._sanitizedCount = msgArray.length;
+    }
+    if (request.prefixProbe) this.recordWireDivergence(msgArray, body.tools);
+    await this.sendStream(body, callbacks, signal);
+  }
+  /** Compare this request's final wire bytes with the previous main-turn
+   *  request's; record the first diverged message. Pure appends record nothing.
+   *  tools 数组单独成维——它不进 messages，消息级对比对其隐形。 */
+  recordWireDivergence(messages, tools) {
+    const sigs = messages.map((m) => {
+      const s = JSON.stringify(m);
+      return { sig: wireHash(s), len: s.length, role: String(m.role ?? "?") };
+    });
+    const toolsSig = tools && tools.length > 0 ? wireHash(stableStringify(tools)) : null;
+    const prev = this.prevWireSignatures;
+    const prevToolsSig = this.prevWireToolsSig;
+    this.prevWireSignatures = sigs;
+    this.prevWireToolsSig = toolsSig;
+    if (!prev) return;
+    if (prevToolsSig !== toolsSig) {
+      this.lastWireDivergence = {
+        idx: -1,
+        role: "tools",
+        kind: "tools_changed",
+        prevCount: prev.length,
+        newCount: sigs.length,
+        approxCharPos: 0
+      };
+      return;
+    }
+    const shared = Math.min(prev.length, sigs.length);
+    let divergedIdx = -1;
+    for (let i = 0; i < shared; i++) {
+      if (prev[i].sig !== sigs[i].sig) {
+        divergedIdx = i;
+        break;
+      }
+    }
+    if (divergedIdx === -1) {
+      if (sigs.length >= prev.length) return;
+      divergedIdx = sigs.length;
+    }
+    let approxCharPos = 0;
+    for (let i = 0; i < divergedIdx; i++) approxCharPos += sigs[i]?.len ?? prev[i].len;
+    this.lastWireDivergence = {
+      idx: divergedIdx,
+      role: sigs[divergedIdx]?.role ?? "removed",
+      kind: divergedIdx >= sigs.length ? "message_removed" : "message_changed",
+      prevCount: prev.length,
+      newCount: sigs.length,
+      approxCharPos
+    };
+  }
+  /** Consume-once accessor for the latest wire-level prefix divergence. */
+  consumeWireDivergence() {
+    const d = this.lastWireDivergence;
+    this.lastWireDivergence = null;
+    return d;
+  }
+  /** Shared inner retry+fetch+SSE loop used by both stream and streamOai. */
+  async sendStream(body, callbacks, signal) {
+    const reasoningRef = { content: "" };
+    const isThinking = this.config.thinking === "enabled";
+    let stripRequested = false;
+    let imagesStripped = false;
+    const estInputTokens = estimateOaiTokens(body.messages ?? []);
+    const derivedFirstByteBaseMs = isThinking ? this.isSlowThinking ? SLOW_FIRST_BYTE_TIMEOUT_MS : REASONING_FIRST_BYTE_TIMEOUT_MS : FIRST_BYTE_TIMEOUT_MS;
+    const firstByteMs = computeFirstByteTimeoutMs({
+      baseMs: this.config.firstByteTimeoutMs ?? derivedFirstByteBaseMs,
+      estInputTokens
+    });
+    await withStructuredRetry(async () => {
+      this.toolCallBuffer.clear();
+      this.toolCallHintFired.clear();
+      this.pendingStopReason = null;
+      this._textAccum = "";
+      this.contentStarted = false;
+      let wireMessages = body.messages;
+      if (stripRequested && !imagesStripped) {
+        const stripped = stripOaiImageParts(wireMessages);
+        if (stripped.removedCount > 0) {
+          wireMessages = stripped.messages;
+          imagesStripped = true;
+          callbacks.onImageStripped?.({ removedCount: stripped.removedCount });
+        }
+      }
+      let effectiveBody = body;
+      const isGlm = this.config.providerName === "glm";
+      if (isThinking && reasoningRef.content && !isGlm) {
+        const msgs = [...wireMessages, {
+          role: "assistant",
+          content: "",
+          reasoning_content: reasoningRef.content
+        }];
+        effectiveBody = { ...body, messages: msgs };
+      } else if (wireMessages !== body.messages) {
+        effectiveBody = { ...body, messages: wireMessages };
+      }
+      const authHeaders = this.config.auth ? await this.config.auth.getHeaders() : { "Authorization": `Bearer ${this.config.apiKey}` };
+      const fetchTimeout = firstByteMs;
+      const lifecycle = new AbortController();
+      if (signal) {
+        if (signal.aborted) lifecycle.abort();
+        else signal.addEventListener("abort", () => lifecycle.abort(), { once: true });
+      }
+      await acquireRateLimitSlot(this.config.providerName ?? this.config.baseUrl, this.config.retry?.rateLimit, lifecycle.signal);
+      const response = await fetchWithTimeout(`${normalizeBaseUrl(this.config.baseUrl)}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Connection": "keep-alive",
+          ...this.config.userAgent ? { "User-Agent": this.config.userAgent } : {},
+          ...authHeaders,
+          ...this.config.sessionId ? { [this.config.sessionHeader ?? "X-Request-Session"]: this.config.sessionId } : {}
+        },
+        body: JSON.stringify(effectiveBody),
+        signal: lifecycle.signal
+      }, fetchTimeout, this.proxyDispatcher);
+      if (!response.ok) {
+        const errorBody = await response.text().catch(() => "");
+        const err = Object.assign(
+          new Error(parseOpenAIError(response.status, errorBody, { providerName: this.config.providerName, baseUrl: this.config.baseUrl, apiKeyEnv: this.config.apiKeyEnv })),
+          {
+            status: response.status,
+            // 413 的两种成因（图片过重 / 上下文超限）在 wire 层同形，分类器无法
+            // 自行区分——只有这里知道刚发出去的体里有没有图。标在错误上让分类器
+            // 分流：无图 = 纯上下文超限，重发同一个体必然再 413，不该重试。
+            ...response.status === 413 ? { payloadHadImages: oaiMessagesHaveImageParts(effectiveBody.messages ?? []) } : {}
+          }
+        );
+        const retryAfter = response.headers.get("retry-after");
+        if (retryAfter) {
+          const retryAfterMs = parseRetryAfterMs(retryAfter);
+          if (retryAfterMs !== void 0) {
+            ;
+            err.retryAfterMs = retryAfterMs;
+          }
+        }
+        throw err;
+      }
+      const contentType = response.headers.get("content-type") ?? "";
+      if (contentType && !contentType.includes("event-stream") && !contentType.includes("octet-stream")) {
+        const snippet = await response.text().catch(() => "");
+        throw Object.assign(
+          new Error(
+            `\u7AEF\u70B9\u8FD4\u56DE 200 \u4F46 content-type \u662F ${contentType}\uFF08\u4E0D\u662F SSE \u6D41\uFF09\u2014\u2014\u7AEF\u70B9\u53EF\u80FD\u4E0D\u652F\u6301\u6D41\u5F0F\uFF0C\u6216\u8DEF\u5F84\u9519\u8BEF\uFF08baseUrl \u662F\u5426\u7F3A /v1\uFF1F\uFF09\u3002baseUrl=${this.config.baseUrl}\u3002\u54CD\u5E94\u7247\u6BB5\uFF1A${snippet.slice(0, 200)}`
+          ),
+          { status: 200, nonSse: true }
+        );
+      }
+      const reader = response.body?.getReader();
+      if (!reader) throw new Error("Response body is not readable");
+      await this.parseStreamFromReader(reader, callbacks, signal, reasoningRef, lifecycle, firstByteMs);
+    }, signal, {
+      maxTotalDurationMs: this.config.retry?.maxTotalDurationMs ?? (this.config.providerName === "glm" ? 20 * 6e4 : 10 * 6e4),
+      // Thinking retries are normally throttled to 1 because re-reasoning is costly.
+      // 例外：slow-thinking providers 在被中止的那次尝试里已把整个 prompt 灌进服务端
+      // 前缀缓存，重试命中近 100% 缓存（实测 deepseek 99.4% hit、~12s 完成），代价极低。
+      // 给它们 2 次重试，让「单次服务端 thinking 卡死」甚至「连续两次卡死」都能自愈而
+      // 不冒泡成错误。maxTotalDurationMs 仍是总时长兜底，防 runaway。
+      // An explicit provider maxRetries overrides the built-in thinking budget (0 disables retries).
+      maxTotalRetries: this.config.maxRetries ?? (isThinking ? this.isSlowThinking ? 2 : 1 : void 0),
+      policy: this.config.retry,
+      onRetry: (info) => {
+        if (info.classified.category === "rate_limit") {
+          callbacks.onRateLimit?.(info.classified.retryDelayMs);
+        }
+        if (info.classified.category === "image_strip") {
+          stripRequested = true;
+        }
+      }
+    });
+  }
+  /** Parse SSE stream from a reader — exposed for testing */
+  /** Parse SSE stream from a reader — exposed for testing */
+  async parseStreamFromReader(reader, callbacks, signal, reasoningRef, lifecycle, firstByteTimeoutMs) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let streamTimedOut = false;
+    let idleTimer = null;
+    let receivedFirstChunk = false;
+    let lastIdleTimeoutMs = 0;
+    let lastFiredAsThinkingStall = false;
+    let receivedThinking = false;
+    let reasoningAccum = "";
+    let textReceived = false;
+    let promotionFired = false;
+    let toolProgressReceived = false;
+    const repetitionGuard = this.config.providerName === "deepseek" ? new ReasoningRepetitionGuard() : void 0;
+    const processPayload = (payload) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(payload);
+      } catch {
+        return;
+      }
+      if (!parsed || typeof parsed !== "object") return;
+      const delta = parsed?.choices?.[0]?.delta;
+      if (parsed.choices?.[0] && !delta) return;
+      if (delta?.tool_calls?.length) toolProgressReceived = true;
+      if (delta?.reasoning_content && !textReceived) {
+        reasoningAccum += delta.reasoning_content;
+        receivedThinking = true;
+        if (reasoningRef) reasoningRef.content = reasoningAccum;
+        if (!delta.content && !toolProgressReceived && this.toolCallBuffer.size === 0) {
+          repetitionGuard?.push(delta.reasoning_content);
+        }
+      }
+      this.processDelta(parsed, callbacks);
+      if (delta?.content) textReceived = true;
+    };
+    const timeoutController = new AbortController();
+    const isGlm = this.config.providerName === "glm";
+    const explicitRequestTimeoutMs = this.config.requestTimeoutMs;
+    const baseStreamMs = explicitRequestTimeoutMs ?? (isGlm ? 20 * 6e4 : 10 * 6e4);
+    const streamStartedAt = Date.now();
+    let lastDataEventAt = streamStartedAt;
+    let hardCapExtended = false;
+    const progressWindowMs = isGlm ? GLM_HARD_CAP_PROGRESS_WINDOW_MS : HARD_CAP_PROGRESS_WINDOW_MS;
+    const checkHardCap = () => {
+      const action = decideStreamHardCap({
+        now: Date.now(),
+        startedAt: streamStartedAt,
+        lastDataEventAt,
+        baseStreamMs
+      }, progressWindowMs);
+      if (action.kind === "abort") {
+        timeoutController.abort();
+        return;
+      }
+      if (action.extended) hardCapExtended = true;
+      maxStreamTimer = setTimeout(checkHardCap, action.rearmMs);
+    };
+    let maxStreamTimer = explicitRequestTimeoutMs !== void 0 ? setTimeout(() => timeoutController.abort(), explicitRequestTimeoutMs) : setTimeout(checkHardCap, baseStreamMs);
+    const signalCleanup = signal ? wireAbortToReaderCancel(AbortSignal.any([signal, timeoutController.signal]), reader) : wireAbortToReaderCancel(timeoutController.signal, reader);
+    const resetIdleTimer = () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      const isReasoning = this.config.thinking === "enabled";
+      const isSlowProvider = this.isSlowThinking;
+      const firstByteMs = firstByteTimeoutMs ?? (isSlowProvider ? SLOW_FIRST_BYTE_TIMEOUT_MS : isReasoning ? REASONING_FIRST_BYTE_TIMEOUT_MS : FIRST_BYTE_TIMEOUT_MS);
+      const isGlm2 = this.config.providerName === "glm";
+      const readMs = isGlm2 && isReasoning ? GLM_READ_TIMEOUT_MS : isSlowProvider ? SLOW_READ_TIMEOUT_MS : isReasoning ? REASONING_READ_TIMEOUT_MS : READ_TIMEOUT_MS;
+      const hasActionableBlock = this.toolCallBuffer.size > 0 || this._textAccum.length > 0;
+      const inThinkingOnly = receivedThinking && !textReceived && !hasActionableBlock;
+      const thinkingStallMs = inThinkingOnly ? Math.min(this.config.thinkingStallTimeoutMs ?? readMs, readMs) : null;
+      const timeout = receivedFirstChunk ? thinkingStallMs ?? readMs : firstByteMs;
+      lastIdleTimeoutMs = timeout;
+      lastFiredAsThinkingStall = thinkingStallMs !== null && thinkingStallMs < readMs;
+      idleTimer = setTimeout(() => {
+        streamTimedOut = true;
+        reader.cancel().catch(() => {
+        });
+      }, timeout);
+    };
+    try {
+      resetIdleTimer();
+      let streamDone = false;
+      const throwIfHardCapAborted = () => {
+        if (!timeoutController.signal.aborted) return;
+        const mins = Math.round((Date.now() - streamStartedAt) / 6e4);
+        throw new Error(explicitRequestTimeoutMs !== void 0 ? `OpenAI SSE stream request timeout (${Math.round(explicitRequestTimeoutMs / 1e3)}s, provider requestTimeoutMs) \u2014 total request duration exceeded configured limit` : hardCapExtended ? `OpenAI SSE stream hard timeout (~${mins}min, progress-extended) \u2014 stream exceeded maximum duration` : "OpenAI SSE stream hard timeout (10min) \u2014 stream stopped progressing");
+      };
+      while (!streamDone) {
+        if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+        throwIfHardCapAborted();
+        const { done, value } = await reader.read();
+        if (streamTimedOut) {
+          const secs = Math.round(lastIdleTimeoutMs / 1e3);
+          const msg = lastFiredAsThinkingStall ? `OpenAI SSE stream thinking stall timeout (${secs}s) \u2014 model stopped producing thinking tokens` : `OpenAI SSE stream idle timeout (${secs}s)`;
+          throw new Error(msg);
+        }
+        if (done) {
+          throwIfHardCapAborted();
+          break;
+        }
+        receivedFirstChunk = true;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        let sawDataEvent = false;
+        for (const line of lines) {
+          const trimmed2 = line.trim();
+          if (!trimmed2 || !trimmed2.startsWith("data:")) continue;
+          const payload = trimmed2.slice(5).trimStart();
+          if (payload === "[DONE]") {
+            streamDone = true;
+            break;
+          }
+          sawDataEvent = true;
+          if (process.env.RIVET_DEBUG_RAW_SSE) this.dumpRawSse(payload);
+          processPayload(payload);
+        }
+        if (sawDataEvent) {
+          lastDataEventAt = Date.now();
+          resetIdleTimer();
+        }
+      }
+      const trimmed = buffer.trim();
+      if (trimmed.startsWith("data:")) {
+        const payload = trimmed.slice(5).trimStart();
+        if (payload !== "[DONE]") processPayload(payload);
+      }
+      this.flushToolCalls(callbacks, { final: true });
+      let textConsumedAsToolJson = false;
+      if (this.toolCallBuffer.size === 0 && this._textAccum && this.config.capabilities?.hasToolJsonInContentBug) {
+        textConsumedAsToolJson = this.tryParseToolJsonFromContent(this._textAccum, callbacks) > 0;
+      }
+      if (reasoningAccum) {
+        callbacks.onContentBlock?.({ type: "thinking", thinking: reasoningAccum });
+      }
+      if (!textReceived && reasoningAccum && this.config.providerName === "glm") {
+        callbacks.onTextDelta?.(reasoningAccum);
+        promotionFired = true;
+      }
+      const finalText = !textConsumedAsToolJson && this._textAccum ? this._textAccum : promotionFired ? reasoningAccum : "";
+      if (finalText) {
+        callbacks.onContentBlock?.({ type: "text", text: finalText });
+      }
+      this._textAccum = "";
+      this.contentStarted = false;
+      if (this.pendingStopReason) {
+        callbacks.onStopReason?.(mapFinishReason(this.pendingStopReason), {});
+        this.pendingStopReason = null;
+      }
+    } catch (err) {
+      void reader.cancel().catch(() => {
+      });
+      callbacks.onStreamAttemptAborted?.({
+        provider: this.config.providerName ?? "openai",
+        receivedChars: reasoningAccum.length + this._textAccum.length,
+        elapsedMs: Date.now() - streamStartedAt,
+        errorName: err?.name ?? "Error",
+        errorMessage: err?.message ?? String(err)
+      });
+      throw wrapBodyTimeoutError(err, "OpenAI", streamStartedAt);
+    } finally {
+      if (idleTimer) clearTimeout(idleTimer);
+      if (maxStreamTimer) clearTimeout(maxStreamTimer);
+      if (signalCleanup) signalCleanup();
+      lifecycle?.abort();
+      if (!textReceived && reasoningAccum && !promotionFired && this.config.providerName === "glm") {
+        callbacks.onTextDelta?.(reasoningAccum);
+      }
+    }
+  }
+  /**
+   * Resolve which toolCallBuffer slot a streaming chunk belongs to.
+   *
+   * Returns the slot index, or null to DROP the chunk. Dropping is the
+   * fail-safe choice when a continuation chunk carries no `index`/`id` and more
+   * than one buffer is open — misgrafting it onto another tool's arguments
+   * corrupts both (the parallel tool_call pollution bug). A dropped trailing
+   * fragment at worst leaves one call's JSON incomplete, which the existing
+   * final-flush + salvageFirstJsonObject path already handles.
+   */
+  resolveToolCallIndex(tc) {
+    if (tc.index !== void 0) return tc.index;
+    if (tc.id !== void 0) {
+      for (const [idx, buf] of this.toolCallBuffer) {
+        if (buf.id === tc.id) {
+          this.logToolStreamEvent({
+            phase: "reattach-by-id",
+            openBuffers: this.toolCallBuffer.size,
+            id: tc.id,
+            name: buf.function.name,
+            argsLen: tc.function?.arguments?.length
+          });
+          return idx;
+        }
+      }
+    }
+    if (this.toolCallBuffer.size === 1) {
+      const idx = this.toolCallBuffer.keys().next().value;
+      this.logToolStreamEvent({
+        phase: "reattach-sole",
+        openBuffers: 1,
+        argsLen: tc.function?.arguments?.length
+      });
+      return idx;
+    }
+    if (this.toolCallBuffer.size === 0) return 0;
+    this.logToolStreamEvent({
+      phase: "drop-ambiguous",
+      openBuffers: this.toolCallBuffer.size,
+      argsLen: tc.function?.arguments?.length
+    });
+    return null;
+  }
+  /** Process a single SSE delta chunk — exposed for testing */
+  processDelta(chunk, callbacks) {
+    const choice = chunk.choices?.[0];
+    if (chunk.usage && choice === void 0) {
+      const usage = chunk.usage;
+      const stopReason = this.pendingStopReason ?? "end_turn";
+      this.pendingStopReason = null;
+      const cacheRead = usage.prompt_cache_hit_tokens ?? usage.prompt_tokens_details?.cached_tokens ?? 0;
+      callbacks.onStopReason?.(mapFinishReason(stopReason), this.calibrateUsage({
+        input_tokens: usage.prompt_tokens ?? 0,
+        output_tokens: usage.completion_tokens ?? 0,
+        cache_read_input_tokens: cacheRead,
+        cache_creation_input_tokens: usage.prompt_cache_miss_tokens ?? 0,
+        reasoning_tokens: usage.completion_tokens_details?.reasoning_tokens
+      }));
+      return;
+    }
+    if (!choice) return;
+    const delta = choice.delta;
+    if (delta.reasoning_content) {
+      if (this.contentStarted) {
+        callbacks.onTextDelta?.(delta.reasoning_content);
+        this._textAccum += delta.reasoning_content;
+      } else {
+        callbacks.onThinkingDelta?.(delta.reasoning_content);
+      }
+    }
+    if (delta.content) {
+      this.contentStarted = true;
+      callbacks.onTextDelta?.(delta.content);
+      this._textAccum += delta.content;
+    }
+    if (delta.tool_calls) {
+      for (const tc of delta.tool_calls) {
+        callbacks.onToolCallDelta?.();
+        const idx = this.resolveToolCallIndex(tc);
+        if (idx === null) continue;
+        const buf = this.toolCallBuffer.get(idx) ?? { function: { arguments: "" } };
+        if (tc.id) buf.id = tc.id;
+        if (tc.type) buf.type = tc.type;
+        if (tc.function?.name) {
+          buf.function.name = (buf.function.name ?? "") + tc.function.name;
+        }
+        if (tc.function?.arguments) {
+          buf.function.arguments += tc.function.arguments;
+        }
+        this.toolCallBuffer.set(idx, buf);
+        if (callbacks.onToolCallHint && buf.function.name && !this.toolCallHintFired.has(idx)) {
+          try {
+            const partial = JSON.parse(buf.function.arguments);
+            this.toolCallHintFired.add(idx);
+            callbacks.onToolCallHint(buf.function.name, partial);
+          } catch {
+          }
+        }
+      }
+    }
+    if (choice.finish_reason) {
+      this.flushToolCalls(callbacks);
+      this.pendingStopReason = choice.finish_reason;
+    }
+    if (chunk.usage && this.pendingStopReason !== null) {
+      const usage = chunk.usage;
+      const stopReason = this.pendingStopReason;
+      this.pendingStopReason = null;
+      const cacheRead = usage.prompt_cache_hit_tokens ?? usage.prompt_tokens_details?.cached_tokens ?? 0;
+      callbacks.onStopReason?.(mapFinishReason(stopReason), this.calibrateUsage({
+        input_tokens: usage.prompt_tokens ?? 0,
+        output_tokens: usage.completion_tokens ?? 0,
+        cache_read_input_tokens: cacheRead,
+        cache_creation_input_tokens: usage.prompt_cache_miss_tokens ?? 0,
+        reasoning_tokens: usage.completion_tokens_details?.reasoning_tokens
+      }));
+    }
+  }
+  /**
+   * Emit buffered tool_use blocks.
+   *
+   * Called twice per stream: once when `finish_reason` arrives (non-final) and
+   * once at end-of-stream (`final: true`). On the non-final flush, entries whose
+   * arguments are not yet valid JSON are LEFT in the buffer so trailing argument
+   * deltas (GLM-5.2 sends them after finish_reason) can complete them before the
+   * final flush. Only emitted entries are removed — the buffer is never cleared
+   * wholesale, so a deferred entry survives to the final flush.
+   */
+  flushToolCalls(callbacks, opts = {}) {
+    const final = opts.final ?? false;
+    for (const [idx, buf] of this.toolCallBuffer) {
+      if (!buf.id || !buf.function.name) {
+        if (final) this.toolCallBuffer.delete(idx);
+        continue;
+      }
+      const parsed = tryParseToolArguments(buf.function.arguments);
+      if (parsed === null) {
+        if (!final) {
+          this.maybeTraceToolStream("defer", idx, buf);
+          continue;
+        }
+        this.warnToolArgParseFailure(buf);
+        this.logToolStreamEvent({
+          phase: "final-flush-empty",
+          openBuffers: this.toolCallBuffer.size,
+          id: buf.id,
+          name: buf.function.name,
+          argsLen: buf.function.arguments.length
+        });
+        callbacks.onContentBlock?.({ type: "tool_use", id: buf.id, name: buf.function.name, input: {}, argsTruncated: true });
+        this.toolCallBuffer.delete(idx);
+        continue;
+      }
+      this.maybeTraceToolStream(final ? "emit-final" : "emit", idx, buf);
+      callbacks.onContentBlock?.({ type: "tool_use", id: buf.id, name: buf.function.name, input: parsed });
+      this.toolCallBuffer.delete(idx);
+    }
+  }
+  /**
+   * Append one raw SSE `data:` payload to disk for offline analysis.
+   * Gated by RIVET_DEBUG_RAW_SSE: `1` → `<cwd>/.rivet/raw-sse[-<sessionId>].jsonl`,
+   * any other value is treated as an explicit target file path.
+   */
+  dumpRawSse(payload) {
+    const env = process.env.RIVET_DEBUG_RAW_SSE;
+    if (!env) return;
+    if (this.rawSsePath === void 0) {
+      const target = env === "1" ? join(process.cwd(), ".rivet", `raw-sse${this.config.sessionId ? `-${this.config.sessionId}` : ""}.jsonl`) : env;
+      try {
+        mkdirSync(dirname(target), { recursive: true });
+        this.rawSsePath = target;
+      } catch {
+        this.rawSsePath = null;
+      }
+    }
+    if (!this.rawSsePath) return;
+    try {
+      appendFileSync(this.rawSsePath, `${JSON.stringify({ t: Date.now(), model: this.config.model, payload })}
+`);
+    } catch {
+    }
+  }
+  /** Gated stream-level tool-call diagnostics (RIVET_DEBUG_TOOL_STREAM=1). */
+  maybeTraceToolStream(phase, idx, buf) {
+    if (process.env.RIVET_DEBUG_TOOL_STREAM !== "1") return;
+    debugLog(
+      `[tool-stream] phase=${phase} idx=${idx} id=${buf.id ?? "?"} name=${buf.function.name ?? "?"} argsLen=${buf.function.arguments.length} args=${JSON.stringify(redactSensitiveArgs(buf.function.arguments.slice(0, 200)))}`
+    );
+  }
+  /**
+   * Append one notable tool-stream event to the always-on session log. Unlike
+   * maybeTraceToolStream (gated, stderr), this writes to disk by default so the
+   * cross-tool argument-pollution class of bug leaves a trace without anyone
+   * having to enable RIVET_DEBUG up front. Best-effort: any IO failure disables
+   * further logging for this client (sets path to null), never throws.
+   *
+   * Security: events carry argsLen only, NEVER raw argument content — tool
+   * arguments can embed secrets (passwords/tokens passed to Bash etc.) and an
+   * always-on disk log must not capture them (CWE-532). Content previews exist
+   * only in the RIVET_DEBUG_TOOL_STREAM stderr path, redacted.
+   *
+   * Capped at TOOL_STREAM_LOG_MAX_LINES per process — once hit, logging stops to
+   * bound disk on long sessions. The cap is generous: these events are rare
+   * (only fire on ambiguous continuation chunks / final-flush empties), so
+   * hitting the cap itself signals a provider streaming pathology worth flagging.
+   */
+  logToolStreamEvent(event) {
+    if (this.toolStreamLogPath === null) return;
+    if (this.toolStreamLogLines >= TOOL_STREAM_LOG_MAX_LINES) return;
+    if (this.toolStreamLogPath === void 0) {
+      try {
+        const file = join(
+          process.cwd(),
+          ".rivet",
+          `tool-stream${this.config.sessionId ? `-${this.config.sessionId}` : ""}.jsonl`
+        );
+        mkdirSync(dirname(file), { recursive: true });
+        this.toolStreamLogPath = file;
+      } catch {
+        this.toolStreamLogPath = null;
+        return;
+      }
+    }
+    try {
+      appendFileSync(this.toolStreamLogPath, `${JSON.stringify({
+        t: (/* @__PURE__ */ new Date()).toISOString(),
+        model: this.config.model,
+        provider: this.config.providerName ?? null,
+        session: this.config.sessionId ?? null,
+        ...event
+      })}
+`);
+      this.toolStreamLogLines++;
+    } catch {
+      this.toolStreamLogPath = null;
+    }
+  }
+  /** Diagnostic log when a tool call's arguments never became valid JSON.
+   *
+   * Kept debug-only to avoid writing directly to stderr and corrupting the TUI
+   * render (the failure is already surfaced to the model/user through the
+   * `argsTruncated` tool_use block + tool_result error). Offline diagnosis is
+   * still available via the tool-stream JSONL event log and RIVET_DEBUG.
+   */
+  warnToolArgParseFailure(buf) {
+    const msg = `[tool-arg-parse-failure] id=${buf.id ?? "?"} name=${buf.function.name ?? "?"} argsLen=${buf.function.arguments.length} args=${JSON.stringify(redactSensitiveArgs(buf.function.arguments.slice(0, 300)))}`;
+    debugLog(msg);
+  }
+  /**
+   * Calibrate API-reported usage for providers with inflated prompt_tokens.
+   * When usageCalibrationFactor=0 (GLM coding API), replace input_tokens with
+   * a local chars/4 estimate and scale cache fields proportionally.
+   */
+  calibrateUsage(usage) {
+    const factor = this.config.usageCalibrationFactor;
+    if (factor === void 0 || factor >= 1) return usage;
+    if (factor <= 0) {
+      const estTokens = estimateRequestTokens(this.lastRequestMessages);
+      const apiRatio = usage.input_tokens > 0 ? estTokens / usage.input_tokens : 1;
+      return {
+        ...usage,
+        input_tokens: estTokens,
+        cache_read_input_tokens: Math.round(usage.cache_read_input_tokens * apiRatio),
+        cache_creation_input_tokens: Math.round(usage.cache_creation_input_tokens * apiRatio)
+      };
+    }
+    return {
+      ...usage,
+      input_tokens: Math.round(usage.input_tokens * factor),
+      cache_read_input_tokens: Math.round(usage.cache_read_input_tokens * factor),
+      cache_creation_input_tokens: Math.round(usage.cache_creation_input_tokens * factor)
+    };
+  }
+  /** 网#1: Parse tool JSON from accumulated text content (DeepSeek bug workaround).
+   *  Returns the number of tool_use blocks emitted so the caller knows whether
+   *  the text was consumed as tool calls (and must not also persist as text). */
+  tryParseToolJsonFromContent(text, callbacks) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return 0;
+    try {
+      const parsed = JSON.parse(trimmed);
+      const toolCalls = Array.isArray(parsed) ? parsed : [parsed];
+      let emitted = 0;
+      for (const tc of toolCalls) {
+        if (typeof tc !== "object" || tc === null) continue;
+        const obj = tc;
+        if (typeof obj.name !== "string") continue;
+        const input = typeof obj.arguments === "object" && obj.arguments !== null ? obj.arguments : typeof obj.arguments === "string" ? (() => {
+          try {
+            return JSON.parse(obj.arguments);
+          } catch {
+            return {};
+          }
+        })() : {};
+        callbacks.onContentBlock?.({ type: "tool_use", id: `fallback_${obj.name}_${emitted}`, name: obj.name, input });
+        emitted++;
+      }
+      return emitted;
+    } catch {
+      return 0;
+    }
+  }
+};
+function estimateRequestTokens(messages) {
+  let chars = 0;
+  for (const msg of messages) {
+    if (typeof msg.content === "string") chars += msg.content.length;
+    else if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (typeof part === "object" && part !== null && "text" in part) {
+          chars += String(part.text).length;
+        }
+      }
+    }
+    if (msg.role === "assistant") {
+      const m = msg;
+      if (typeof m.reasoning_content === "string") chars += m.reasoning_content.length;
+      if (Array.isArray(m.tool_calls)) chars += JSON.stringify(m.tool_calls).length;
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "end_turn";
+    case "tool_calls":
+      return "tool_use";
+    case "length":
+      return "max_tokens";
+    case "insufficient_system_resource":
+      return "end_turn";
+    // DeepSeek-specific
+    default:
+      return "end_turn";
+  }
+}
+function apiErrorHint(code, message, provider) {
+  const probe = `${code} ${typeof message === "string" ? message : ""}`;
+  if (!/insufficient[ _-]?(balance|quota)|余额不足|额度不足/i.test(probe)) return "";
+  const where = `${provider?.providerName ?? ""} ${provider?.baseUrl ?? ""}`.toLowerCase();
+  const BILLING = [
+    [/deepseek/, "DeepSeek", "https://platform.deepseek.com/top_up"],
+    [/siliconflow|硅基/, "SiliconFlow", "https://cloud.siliconflow.cn"],
+    [/bigmodel|zhipu|智谱|glm/, "\u667A\u8C31 GLM", "https://www.bigmodel.cn"],
+    [/minimax/, "MiniMax", "https://platform.minimaxi.com"],
+    [/moonshot|kimi/, "Kimi", "https://platform.moonshot.cn"]
+  ];
+  for (const [re, name, url] of BILLING) {
+    if (re.test(where)) {
+      return `
+\u63D0\u793A\uFF1A${name} \u8D26\u6237\u4F59\u989D\u4E0D\u8DB3\uFF0C\u5145\u503C\u540E\u91CD\u8BD5\uFF1A${url} \u2014\u2014 \u6216\u7528 /model \u4E34\u65F6\u5207\u6362\u5230\u5176\u4ED6 provider\u3002`;
+    }
+  }
+  return "\n\u63D0\u793A\uFF1A\u5F53\u524D provider \u8D26\u6237\u4F59\u989D\u4E0D\u8DB3\uFF0C\u8BF7\u5145\u503C\u540E\u91CD\u8BD5\uFF0C\u6216\u7528 /model \u5207\u6362\u5230\u5176\u4ED6 provider\u3002";
+}
+function statusHint(status, provider) {
+  if (status === 401 || status === 403) {
+    const envPart = provider?.apiKeyEnv ? `\u2014\u2014\u8BF7\u68C0\u67E5\u73AF\u5883\u53D8\u91CF ${provider.apiKeyEnv} \u662F\u5426\u5DF2\u5BFC\u51FA\u4E14\u672A\u8FC7\u671F` : "\u2014\u2014\u8BF7\u68C0\u67E5 API key \u662F\u5426\u6B63\u786E";
+    return `
+\u63D0\u793A\uFF1A\u9274\u6743\u5931\u8D25\uFF08HTTP ${status}\uFF09${envPart}\uFF0C\u6216\u7528 /connect \u91CD\u65B0\u914D\u7F6E\u3002`;
+  }
+  if (status === 404) {
+    return "\n\u63D0\u793A\uFF1A404 \u901A\u5E38\u662F\u6A21\u578B id \u62FC\u9519\u6216\u7AEF\u70B9\u8DEF\u5F84\u4E0D\u5BF9\u2014\u2014\u8FD0\u884C `rivet provider models <provider>` \u6838\u5BF9\u7AEF\u70B9\u5B9E\u9645\u63D0\u4F9B\u7684\u6A21\u578B id\u3002";
+  }
+  return "";
+}
+function parseOpenAIError(status, body, provider) {
+  try {
+    const parsed = JSON.parse(body);
+    const code = parsed.error?.code ?? parsed.error?.type ?? `HTTP ${status}`;
+    const message = parsed.error?.message ?? body;
+    return `OpenAI API error (${code}): ${message}${apiErrorHint(String(code), String(message), provider)}${statusHint(status, provider)}`;
+  } catch {
+    return `OpenAI API error (HTTP ${status}): ${body}${statusHint(status, provider)}`;
+  }
+}
+
+// src/api/codex-client.ts
+init_esm_shims();
+var CODEX_USER_AGENT = "codex_cli_rs/0.118.0 (Mac OS 26.3.1; arm64) iTerm.app/3.6.9";
+var CODEX_ORIGINATOR = "codex_cli_rs";
+function extractReasoningTokens(usage) {
+  const details = usage.output_tokens_details;
+  const reasoning = details?.reasoning_tokens;
+  return typeof reasoning === "number" ? reasoning : void 0;
+}
+var CodexClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  setReasoningEffort(_effort) {
+  }
+  setThinking(_mode) {
+  }
+  async stream(request, callbacks, signal) {
+    const body = this.buildRequestBody(request);
+    await withStructuredRetry(async () => {
+      const authHeaders = this.config.auth ? await this.config.auth.getHeaders() : {};
+      const url = `${this.config.baseUrl.replace(/\/+$/, "")}/responses`;
+      const lifecycle = new AbortController();
+      if (signal) {
+        if (signal.aborted) lifecycle.abort();
+        else signal.addEventListener("abort", () => lifecycle.abort(), { once: true });
+      }
+      await acquireRateLimitSlot(this.config.baseUrl, this.config.retry?.rateLimit, lifecycle.signal);
+      const response = await fetchWithTimeout(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": CODEX_USER_AGENT,
+          "Originator": CODEX_ORIGINATOR,
+          "Accept": "text/event-stream",
+          "Connection": "Keep-Alive",
+          ...authHeaders
+        },
+        body: JSON.stringify(body),
+        signal: lifecycle.signal
+      }, 18e4);
+      if (!response.ok) {
+        const errorBody = await response.text().catch(() => "");
+        const err = Object.assign(
+          new Error(`Codex API error (${response.status}): ${errorBody}`),
+          { status: response.status }
+        );
+        const retryAfter = response.headers.get("retry-after");
+        if (retryAfter) {
+          const retryAfterMs = parseRetryAfterMs(retryAfter);
+          if (retryAfterMs !== void 0) {
+            ;
+            err.retryAfterMs = retryAfterMs;
+          }
+        }
+        throw err;
+      }
+      await this.processSSEStream(response, callbacks, signal, lifecycle);
+    }, signal, {
+      maxTotalDurationMs: this.config.retry?.maxTotalDurationMs ?? 10 * 6e4,
+      maxTotalRetries: this.config.maxRetries,
+      policy: this.config.retry,
+      onRetry: (info) => {
+        if (info.classified.category === "rate_limit") {
+          callbacks.onRateLimit?.(info.classified.retryDelayMs);
+        }
+      }
+    });
+  }
+  buildRequestBody(request) {
+    const input = [];
+    let instructions;
+    const nonSystemMessages = request.messages.filter((m) => {
+      if (m.role === "system") {
+        instructions = (instructions ?? "") + m.content;
+        return false;
+      }
+      return true;
+    });
+    for (const msg of nonSystemMessages) {
+      if (msg.role === "user") {
+        input.push({ type: "message", role: "user", content: [{ type: "input_text", text: msg.content }] });
+      } else if (msg.role === "assistant") {
+        const textContent = msg.content ?? "";
+        if (textContent) {
+          input.push({ type: "message", role: "assistant", content: [{ type: "output_text", text: textContent }] });
+        }
+        if (msg.tool_calls) {
+          for (const tc of msg.tool_calls) {
+            input.push({
+              type: "function_call",
+              call_id: tc.id,
+              name: tc.function.name,
+              arguments: tc.function.arguments
+            });
+          }
+        }
+      } else if (msg.role === "tool") {
+        input.push({
+          type: "function_call_output",
+          call_id: msg.tool_call_id,
+          output: msg.content
+        });
+      }
+    }
+    const tools = request.tools?.map((t) => {
+      const fn = t.function;
+      const params = fn.parameters;
+      const properties = params?.properties;
+      const required = Array.isArray(params?.required) ? params.required : void 0;
+      const schema = {
+        type: "object",
+        properties: properties ?? {}
+      };
+      if (required?.length) {
+        schema.required = required;
+      }
+      if (params?.additionalProperties !== void 0) {
+        schema.additionalProperties = params.additionalProperties;
+      }
+      return {
+        type: "function",
+        name: fn.name,
+        description: fn.description,
+        parameters: schema,
+        strict: false
+      };
+    }) ?? [];
+    const body = {
+      model: this.config.model,
+      input,
+      stream: true,
+      store: false,
+      parallel_tool_calls: true,
+      include: ["reasoning.encrypted_content"],
+      reasoning: { effort: "high" }
+    };
+    if (instructions) {
+      body.instructions = instructions;
+    }
+    if (tools.length > 0) {
+      body.tools = tools;
+    }
+    if (request.tool_choice && tools.length > 0) {
+      if (typeof request.tool_choice === "object") {
+        const name = request.tool_choice.function.name;
+        if (tools.some((t) => t.name === name)) {
+          body.tool_choice = { type: "function", name };
+          body.parallel_tool_calls = false;
+        }
+      } else {
+        body.tool_choice = request.tool_choice;
+      }
+    }
+    return body;
+  }
+  async processSSEStream(response, callbacks, signal, lifecycle) {
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error("No response body");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let stopReason = null;
+    let usage;
+    const functionCalls = /* @__PURE__ */ new Map();
+    let pendingMessageItem = null;
+    let seenReasoningItem = false;
+    let seenTextDelta = false;
+    const flushPendingMessage = () => {
+      if (!pendingMessageItem) return;
+      if (!seenTextDelta) {
+        for (const t of pendingMessageItem.texts) {
+          callbacks.onTextDelta(t);
+        }
+      }
+      for (const b of pendingMessageItem.blocks) {
+        callbacks.onContentBlock(b);
+      }
+      if (pendingMessageItem.msgUsage) {
+        usage = {
+          input_tokens: pendingMessageItem.msgUsage.input_tokens,
+          output_tokens: pendingMessageItem.msgUsage.output_tokens,
+          reasoning_tokens: extractReasoningTokens(pendingMessageItem.msgUsage)
+        };
+      }
+      pendingMessageItem = null;
+    };
+    const FIRST_BYTE_TIMEOUT_MS2 = 18e4;
+    const READ_TIMEOUT_MS2 = 3e5;
+    const THINKING_STALL_TIMEOUT_MS = 9e4;
+    let streamTimedOut = false;
+    let idleTimer = null;
+    let receivedFirstChunk = false;
+    let receivedThinking = false;
+    let textReceived = false;
+    let receivedChars = 0;
+    const timeoutController = new AbortController();
+    const maxStreamMs = 10 * 6e4;
+    const maxStreamTimer = setTimeout(() => timeoutController.abort(), maxStreamMs);
+    const streamStartedAt = Date.now();
+    const signalCleanup = signal ? wireAbortToReaderCancel(AbortSignal.any([signal, timeoutController.signal]), reader) : wireAbortToReaderCancel(timeoutController.signal, reader);
+    const resetIdleTimer = () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      const thinkingStallMs = receivedThinking && !textReceived ? THINKING_STALL_TIMEOUT_MS : null;
+      const timeout = receivedFirstChunk ? thinkingStallMs ?? READ_TIMEOUT_MS2 : FIRST_BYTE_TIMEOUT_MS2;
+      idleTimer = setTimeout(() => {
+        streamTimedOut = true;
+        reader.cancel().catch(() => {
+        });
+      }, timeout);
+    };
+    try {
+      resetIdleTimer();
+      while (true) {
+        if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+        if (timeoutController.signal.aborted) {
+          throw new Error("Codex SSE stream hard timeout (10min) \u2014 stream exceeded maximum duration");
+        }
+        const { done, value } = await reader.read();
+        if (streamTimedOut) throw new Error("Codex SSE stream idle timeout (300s)");
+        if (done) break;
+        receivedFirstChunk = true;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        let sawDataEvent = false;
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") continue;
+          sawDataEvent = true;
+          let parsed;
+          try {
+            parsed = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          const type = parsed.type;
+          switch (type) {
+            case "response.output_text.delta": {
+              seenTextDelta = true;
+              textReceived = true;
+              const text = typeof parsed.delta === "string" ? parsed.delta : parsed.delta?.text;
+              if (text) {
+                receivedChars += text.length;
+                callbacks.onTextDelta(text);
+              }
+              break;
+            }
+            case "response.reasoning_text.delta":
+            case "response.reasoning_summary_text.delta": {
+              seenReasoningItem = true;
+              receivedThinking = true;
+              const text = typeof parsed.delta === "string" ? parsed.delta : parsed.delta?.text;
+              if (text) {
+                receivedChars += text.length;
+                callbacks.onThinkingDelta(text);
+              }
+              break;
+            }
+            case "response.output_item.added": {
+              const item = parsed.item;
+              if (item?.type === "function_call") callbacks.onToolCallDelta?.();
+              break;
+            }
+            case "response.function_call_arguments.delta": {
+              callbacks.onToolCallDelta?.();
+              break;
+            }
+            case "response.output_item.done": {
+              const item = parsed.item;
+              if (item?.type === "function_call") {
+                const callId = item.call_id ?? `call_${functionCalls.size}`;
+                const name = item.name ?? "";
+                const args = item.arguments ?? "";
+                functionCalls.set(functionCalls.size, { id: callId, name, arguments: args });
+                try {
+                  const input = JSON.parse(args);
+                  callbacks.onContentBlock({ type: "tool_use", id: callId, name, input });
+                } catch {
+                }
+              } else if (item?.type === "reasoning") {
+                seenReasoningItem = true;
+                const summary = item.summary;
+                if (summary) {
+                  for (const s of summary) {
+                    if (typeof s.text === "string") {
+                      callbacks.onThinkingDelta(s.text);
+                    }
+                  }
+                }
+                flushPendingMessage();
+              } else if (item?.type === "message") {
+                const content = item.content;
+                const msgUsage = item.usage;
+                if (!seenReasoningItem) {
+                  const texts = [];
+                  const blocks = [];
+                  if (content) {
+                    for (const part of content) {
+                      if (part.type === "output_text" && typeof part.text === "string") {
+                        texts.push(part.text);
+                        blocks.push({ type: "text", text: part.text });
+                      }
+                    }
+                  }
+                  pendingMessageItem = { texts, blocks, msgUsage };
+                } else {
+                  if (content) {
+                    for (const part of content) {
+                      if (part.type === "output_text" && typeof part.text === "string") {
+                        if (!seenTextDelta) callbacks.onTextDelta(part.text);
+                        callbacks.onContentBlock({ type: "text", text: part.text });
+                      }
+                    }
+                  }
+                  if (msgUsage) {
+                    usage = {
+                      input_tokens: msgUsage.input_tokens,
+                      output_tokens: msgUsage.output_tokens,
+                      reasoning_tokens: extractReasoningTokens(msgUsage)
+                    };
+                  }
+                }
+              }
+              break;
+            }
+            case "response.completed": {
+              const resp = parsed.response;
+              if (resp?.usage) {
+                const u = resp.usage;
+                usage = {
+                  input_tokens: u.input_tokens,
+                  output_tokens: u.output_tokens,
+                  reasoning_tokens: extractReasoningTokens(u)
+                };
+              }
+              stopReason = "stop";
+              break;
+            }
+            case "response.failed": {
+              const resp = parsed.response;
+              const error = resp?.error;
+              const msg = error?.message ?? "Codex request failed";
+              throw new Error(msg);
+            }
+            case "error": {
+              const rawMsg = parsed.message ?? parsed.error;
+              let msg;
+              if (typeof rawMsg === "string") {
+                msg = rawMsg;
+              } else if (typeof rawMsg === "object" && rawMsg !== null) {
+                const errObj = rawMsg;
+                msg = errObj.message ?? errObj.error ?? JSON.stringify(errObj);
+              } else {
+                msg = "Unknown Codex error";
+              }
+              throw new Error(`Codex stream error: ${msg}`);
+            }
+          }
+        }
+        if (sawDataEvent) resetIdleTimer();
+      }
+    } catch (err) {
+      callbacks.onStreamAttemptAborted?.({
+        provider: "codex",
+        receivedChars,
+        elapsedMs: Date.now() - streamStartedAt,
+        errorName: err?.name ?? "Error",
+        errorMessage: err?.message ?? String(err)
+      });
+      throw wrapBodyTimeoutError(err, "Codex", streamStartedAt);
+    } finally {
+      if (idleTimer) clearTimeout(idleTimer);
+      if (maxStreamTimer) clearTimeout(maxStreamTimer);
+      if (signalCleanup) signalCleanup();
+      reader.releaseLock();
+      lifecycle?.abort();
+    }
+    flushPendingMessage();
+    callbacks.onStopReason(stopReason ?? "stop", {
+      input_tokens: usage?.input_tokens ?? 0,
+      output_tokens: usage?.output_tokens ?? 0,
+      cache_creation_input_tokens: 0,
+      cache_read_input_tokens: 0,
+      reasoning_tokens: usage?.reasoning_tokens
+    });
+  }
+};
+
+// src/api/anthropic-client.ts
+init_esm_shims();
+var import_undici2 = __toESM(require_undici(), 1);
+function foldConsecutiveSameRole(messages) {
+  const out = [];
+  for (const msg of messages) {
+    const prev = out[out.length - 1];
+    if (prev && prev.role === msg.role) {
+      prev.content.push(...msg.content);
+    } else {
+      out.push({ role: msg.role, content: [...msg.content] });
+    }
+  }
+  return out;
+}
+var AnthropicClient = class {
+  constructor(config) {
+    this.config = config;
+    this.proxyDispatcher = config.proxy ? new import_undici2.ProxyAgent(config.proxy) : void 0;
+  }
+  config;
+  /** undici ProxyAgent for config.proxy (undefined = no per-provider proxy). */
+  proxyDispatcher;
+  setReasoningEffort(_effort) {
+  }
+  setThinking(_mode) {
+  }
+  async stream(request, callbacks, signal) {
+    let stripRequested = false;
+    let imagesStripped = false;
+    await withStructuredRetry(async () => {
+      let wireMessages = request.messages;
+      if (stripRequested && !imagesStripped) {
+        const stripped = stripOaiImageParts(wireMessages);
+        if (stripped.removedCount > 0) {
+          wireMessages = stripped.messages;
+          imagesStripped = true;
+          callbacks.onImageStripped?.({ removedCount: stripped.removedCount });
+        }
+      }
+      const body = this.buildRequestBody({ ...request, messages: wireMessages });
+      const lifecycle = new AbortController();
+      if (signal) {
+        if (signal.aborted) lifecycle.abort();
+        else signal.addEventListener("abort", () => lifecycle.abort(), { once: true });
+      }
+      await acquireRateLimitSlot(this.config.baseUrl, this.config.retry?.rateLimit, lifecycle.signal);
+      const response = await fetchWithTimeout(`${normalizeBaseUrl(this.config.baseUrl)}/v1/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.config.apiKey,
+          "anthropic-version": "2023-06-01",
+          "Accept": "text/event-stream",
+          ...this.config.userAgent ? { "User-Agent": this.config.userAgent } : {},
+          ...this.config.sessionId ? { [this.config.sessionHeader ?? "X-Request-Session"]: this.config.sessionId } : {}
+        },
+        body: JSON.stringify(body),
+        signal: lifecycle.signal
+      }, this.config.thinkingBudget && this.config.thinkingBudget > 0 ? 9e4 : 45e3, this.proxyDispatcher);
+      if (!response.ok) {
+        const errorBody = await response.text().catch(() => "");
+        const err = Object.assign(
+          new Error(`Anthropic API error (${response.status}): ${errorBody}`),
+          {
+            status: response.status,
+            // 413 的两种成因在 wire 层同形——只有这里知道刚发出去的体里有没有图。
+            // 标在错误上让分类器分流（无图 = 纯上下文超限，重发无用）。
+            ...response.status === 413 ? { payloadHadImages: oaiMessagesHaveImageParts(wireMessages) } : {}
+          }
+        );
+        const retryAfter = response.headers.get("retry-after");
+        if (retryAfter) {
+          const retryAfterMs = parseRetryAfterMs(retryAfter);
+          if (retryAfterMs !== void 0) {
+            ;
+            err.retryAfterMs = retryAfterMs;
+          }
+        }
+        throw err;
+      }
+      await this.processSSEStream(response, callbacks, signal, lifecycle);
+    }, signal, {
+      maxTotalDurationMs: this.config.retry?.maxTotalDurationMs ?? 10 * 6e4,
+      // provider 级 maxRetries 显式配置时覆盖内置默认（0 = 禁用重试）。
+      maxTotalRetries: this.config.maxRetries,
+      policy: this.config.retry,
+      onRetry: (info) => {
+        if (info.classified.category === "rate_limit") {
+          callbacks.onRateLimit?.(info.classified.retryDelayMs);
+        }
+        if (info.classified.category === "image_strip") {
+          stripRequested = true;
+        }
+      }
+    });
+  }
+  /** Exposed for testing. */
+  buildRequestBodyForTest(request) {
+    return this.buildRequestBody(request);
+  }
+  buildRequestBody(request) {
+    let systemText = "";
+    const nonSystemMessages = request.messages.filter((m) => {
+      if (m.role === "system") {
+        systemText += (systemText ? "\n\n" : "") + m.content;
+        return false;
+      }
+      return true;
+    });
+    const system = systemText ? [{ type: "text", text: systemText }] : [];
+    const messages = foldConsecutiveSameRole(nonSystemMessages.map((m) => this.convertMessage(m)));
+    const tools = request.tools && request.tools.length > 0 ? [...request.tools].sort((a, b) => a.function.name.localeCompare(b.function.name)).map((t) => ({
+      name: t.function.name,
+      description: t.function.description,
+      input_schema: t.function.parameters
+    })) : void 0;
+    const body = {
+      // 空 model 回退到 client 绑定值（侧路调用契约，同 openai-client）。
+      model: request.model || this.config.model,
+      max_tokens: request.max_tokens ?? this.config.maxTokens,
+      messages,
+      stream: true
+    };
+    if (system.length > 0) body.system = system;
+    if (tools) body.tools = tools;
+    if (this.config.thinkingBudget && this.config.thinkingBudget > 0) {
+      body.thinking = { type: "enabled", budget_tokens: this.config.thinkingBudget };
+    } else if (this.config.temperature !== void 0) {
+      body.temperature = Math.max(0, Math.min(1, this.config.temperature));
+    }
+    if (request.tool_choice && typeof request.tool_choice === "object" && tools) {
+      const name = request.tool_choice.function.name;
+      if (tools.some((t) => t.name === name)) {
+        body.tool_choice = { type: "tool", name };
+      }
+    }
+    if (tools && tools.length > 0) {
+      tools[tools.length - 1].cache_control = { type: "ephemeral", ttl: "1h" };
+    }
+    if (system.length > 0) {
+      system[system.length - 1].cache_control = { type: "ephemeral", ttl: "1h" };
+    }
+    let firstUserIdx = -1;
+    for (let i = 0; i < messages.length; i++) {
+      if (messages[i].role === "user") {
+        firstUserIdx = i;
+        break;
+      }
+    }
+    if (firstUserIdx >= 0) {
+      const blocks = messages[firstUserIdx].content;
+      if (blocks.length > 0) {
+        blocks[blocks.length - 1].cache_control = { type: "ephemeral" };
+      }
+    }
+    const MAX_LOOKBACK = 15;
+    let totalBlocks = 0;
+    for (const msg of messages) {
+      totalBlocks += msg.content.length;
+    }
+    let bp4Idx = -1;
+    let blockPos = 0;
+    for (let i = 0; i < messages.length; i++) {
+      blockPos += messages[i].content.length;
+      if (messages[i].role === "assistant" && i !== firstUserIdx) {
+        const fromEnd = totalBlocks - blockPos;
+        if (fromEnd < MAX_LOOKBACK) {
+          bp4Idx = i;
+          break;
+        }
+      }
+    }
+    if (bp4Idx >= 0) {
+      const bp4Blocks = messages[bp4Idx].content;
+      if (bp4Blocks.length > 0) {
+        bp4Blocks[bp4Blocks.length - 1].cache_control = { type: "ephemeral" };
+      }
+    }
+    return body;
+  }
+  convertMessage(msg) {
+    if (msg.role === "user") {
+      if (Array.isArray(msg.content)) {
+        return {
+          role: "user",
+          content: msg.content.map((p) => {
+            if (p.type === "text") return { type: "text", text: p.text };
+            const url = p.image_url.url;
+            const m = url.match(/^data:(image\/[a-z+]+);base64,(.+)$/);
+            if (m) return { type: "image", source: { type: "base64", media_type: m[1], data: m[2] } };
+            return { type: "text", text: `[unsupported image: ${url.slice(0, 50)}]` };
+          })
+        };
+      }
+      return {
+        role: "user",
+        content: [{ type: "text", text: msg.content }]
+      };
+    }
+    if (msg.role === "tool") {
+      return {
+        role: "user",
+        content: [{ type: "tool_result", tool_use_id: msg.tool_call_id, content: msg.content }]
+      };
+    }
+    if (msg.role === "assistant") {
+      const blocks = [];
+      let text = msg.content ?? "";
+      if (msg.reasoning_content) {
+        text = `<thinking>
+${msg.reasoning_content}
+</thinking>
+
+${text}`;
+      }
+      if (text) {
+        blocks.push({ type: "text", text });
+      }
+      if (msg.tool_calls) {
+        for (const tc of msg.tool_calls) {
+          const input = parseJsonObjectWithEscapeRepair(tc.function.arguments) ?? {};
+          blocks.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.function.name,
+            input
+          });
+        }
+      }
+      return { role: "assistant", content: blocks };
+    }
+    throw new Error(`Unsupported message role in AnthropicClient: ${JSON.stringify(msg)}`);
+  }
+  async processSSEStream(response, callbacks, signal, lifecycle) {
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error("No response body");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let stopReason = null;
+    let usage = {};
+    const textBlocks = [];
+    const thinkingBlocks = [];
+    const toolUseBuffer = /* @__PURE__ */ new Map();
+    const FIRST_BYTE_TIMEOUT_MS2 = this.config.thinkingBudget && this.config.thinkingBudget > 0 ? 9e4 : 45e3;
+    const READ_TIMEOUT_MS2 = this.config.thinkingBudget && this.config.thinkingBudget > 0 ? 18e4 : 12e4;
+    let streamTimedOut = false;
+    let idleTimer = null;
+    let receivedFirstChunk = false;
+    let receivedChars = 0;
+    const timeoutController = new AbortController();
+    const maxStreamMs = this.config.requestTimeoutMs ?? 10 * 6e4;
+    const maxStreamTimer = setTimeout(() => timeoutController.abort(), maxStreamMs);
+    const streamStartedAt = Date.now();
+    const signalCleanup = signal ? wireAbortToReaderCancel(AbortSignal.any([signal, timeoutController.signal]), reader) : wireAbortToReaderCancel(timeoutController.signal, reader);
+    const resetIdleTimer = () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      const timeout = receivedFirstChunk ? READ_TIMEOUT_MS2 : FIRST_BYTE_TIMEOUT_MS2;
+      idleTimer = setTimeout(() => {
+        streamTimedOut = true;
+        reader.cancel().catch(() => {
+        });
+      }, timeout);
+    };
+    try {
+      resetIdleTimer();
+      const throwIfHardCapAborted = () => {
+        if (!timeoutController.signal.aborted) return;
+        throw new Error(this.config.requestTimeoutMs !== void 0 ? `Anthropic SSE stream request timeout (${Math.round(this.config.requestTimeoutMs / 1e3)}s, provider requestTimeoutMs) \u2014 total request duration exceeded configured limit` : "Anthropic SSE stream hard timeout (10min) \u2014 stream exceeded maximum duration");
+      };
+      while (true) {
+        if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+        throwIfHardCapAborted();
+        const { done, value } = await reader.read();
+        if (streamTimedOut) throw new Error("Anthropic SSE stream idle timeout (180s)");
+        if (done) {
+          throwIfHardCapAborted();
+          break;
+        }
+        receivedFirstChunk = true;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        let sawContentEvent = false;
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed.startsWith("event: ")) continue;
+          if (!trimmed.startsWith("data:")) continue;
+          const data = trimmed.startsWith("data: ") ? trimmed.slice(6) : trimmed.slice(5);
+          let parsed;
+          try {
+            parsed = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          const type = parsed.type;
+          if (type !== "ping") sawContentEvent = true;
+          switch (type) {
+            case "message_start": {
+              const msg = parsed.message;
+              if (msg?.usage) {
+                const u = msg.usage;
+                usage = {
+                  input_tokens: u.input_tokens,
+                  cache_read_input_tokens: u.cache_read_input_tokens,
+                  cache_creation_input_tokens: u.cache_creation_input_tokens
+                };
+              }
+              break;
+            }
+            case "content_block_start": {
+              const index = parsed.index;
+              const block = parsed.content_block;
+              if (!block) break;
+              if (block.type === "tool_use" && index !== void 0) {
+                callbacks.onToolCallDelta?.();
+                const id = block.id;
+                const name = block.name;
+                if (id && name) {
+                  toolUseBuffer.set(index, { id, name, partialJson: "" });
+                }
+              }
+              break;
+            }
+            case "content_block_delta": {
+              const index = parsed.index;
+              const delta = parsed.delta;
+              if (!delta) break;
+              if (delta.type === "text_delta" && typeof delta.text === "string") {
+                receivedChars += delta.text.length;
+                textBlocks.push(delta.text);
+                callbacks.onTextDelta(delta.text);
+              } else if (delta.type === "thinking_delta" && typeof delta.thinking === "string") {
+                receivedChars += delta.thinking.length;
+                thinkingBlocks.push(delta.thinking);
+                callbacks.onThinkingDelta(delta.thinking);
+              } else if (delta.type === "input_json_delta" && typeof delta.partial_json === "string" && index !== void 0) {
+                const buf = toolUseBuffer.get(index);
+                if (buf) {
+                  buf.partialJson += delta.partial_json;
+                }
+              }
+              break;
+            }
+            case "content_block_stop": {
+              const index = parsed.index;
+              if (index !== void 0) {
+                const buf = toolUseBuffer.get(index);
+                if (buf) {
+                  let input = {};
+                  let argsTruncated;
+                  const repaired = parseJsonObjectWithEscapeRepair(buf.partialJson || "{}");
+                  if (repaired !== null) {
+                    input = repaired;
+                  } else {
+                    argsTruncated = true;
+                  }
+                  callbacks.onContentBlock({ type: "tool_use", id: buf.id, name: buf.name, input, argsTruncated });
+                  toolUseBuffer.delete(index);
+                }
+              }
+              break;
+            }
+            case "message_delta": {
+              const d = parsed.delta;
+              if (d?.stop_reason) {
+                stopReason = d.stop_reason;
+              }
+              if (parsed.usage) {
+                const u = parsed.usage;
+                usage.output_tokens = u.output_tokens;
+              }
+              break;
+            }
+            case "message_stop": {
+              break;
+            }
+            case "error": {
+              const err = parsed.error;
+              throw new Error(`Anthropic stream error: ${err?.message ?? "Unknown error"}`);
+            }
+          }
+        }
+        if (sawContentEvent) resetIdleTimer();
+      }
+    } catch (err) {
+      callbacks.onStreamAttemptAborted?.({
+        provider: "anthropic",
+        receivedChars,
+        elapsedMs: Date.now() - streamStartedAt,
+        errorName: err?.name ?? "Error",
+        errorMessage: err?.message ?? String(err)
+      });
+      throw wrapBodyTimeoutError(err, "Anthropic", streamStartedAt);
+    } finally {
+      if (idleTimer) clearTimeout(idleTimer);
+      if (maxStreamTimer) clearTimeout(maxStreamTimer);
+      if (signalCleanup) signalCleanup();
+      reader.releaseLock();
+      lifecycle?.abort();
+    }
+    if (textBlocks.length > 0) {
+      callbacks.onContentBlock({ type: "text", text: textBlocks.join("") });
+    }
+    if (thinkingBlocks.length > 0) {
+      callbacks.onContentBlock({ type: "thinking", thinking: thinkingBlocks.join("") });
+    }
+    const rawInput = usage.input_tokens ?? 0;
+    const cacheRead = usage.cache_read_input_tokens ?? 0;
+    const cacheCreation = usage.cache_creation_input_tokens ?? 0;
+    callbacks.onStopReason(stopReason ?? "end_turn", {
+      input_tokens: rawInput + cacheRead + cacheCreation,
+      output_tokens: usage.output_tokens ?? 0,
+      cache_read_input_tokens: cacheRead,
+      cache_creation_input_tokens: cacheCreation
+    });
+  }
+};
+
+// src/api/provider-catalog.ts
+init_esm_shims();
+var TIANSHU_USER_AGENT = `tianshu-harness/${"3.23.0"}`;
+var CATALOG_META = {
+  deepseek: {
+    label: "DeepSeek",
+    wire: { thinkingStallTimeoutMs: 12e4 },
+    notes: [
+      "Exact-prefix cache: first 2 messages must remain stable for 99% hit rate",
+      "Thinking block: {type: enabled} + reasoning_effort"
+    ]
+  },
+  kimi: {
+    label: "Kimi (Moonshot)",
+    wire: { userAgent: "KimiCLI/1.0" },
+    notes: [
+      "Thinking block: {type: enabled} + reasoning_effort",
+      "K3 / K3-256K: reasoning_effort low|high|max (default high); K2.7 Code is Thinking:ON only",
+      "No prefix cache support"
+    ]
+  },
+  glm: {
+    label: "GLM (Zhipu)",
+    wire: { thinkingStallTimeoutMs: 42e4 },
+    notes: [
+      "OpenAI-compatible protocol via /api/paas/v4",
+      "Thinking block: {type: enabled} + reasoning_effort",
+      "Implicit exact-prefix cache (cached_tokens in prompt_tokens_details), 1M context"
+    ]
+  },
+  minimax: {
+    label: "MiniMax",
+    wire: { useMaxCompletionTokens: true },
+    notes: [
+      "MiniMax-M3: 1M context, multimodal (image/video)",
+      "Uses max_completion_tokens instead of max_tokens",
+      "Thinking block: {type: adaptive} + reasoning_split",
+      "No prefix cache support"
+    ]
+  },
+  mimo: {
+    label: "Mimo",
+    wire: { useMaxCompletionTokens: true },
+    notes: [
+      "Thinking block: {type: enabled}",
+      "No thinking effort control",
+      "No cache support"
+    ]
+  },
+  "mimo-api": {
+    label: "MiMo API",
+    wire: { useMaxCompletionTokens: true },
+    notes: [
+      "Pay-as-you-go MiMo API endpoint",
+      "Thinking block: {type: enabled}",
+      "Exact-prefix cache like DeepSeek"
+    ]
+  },
+  "opencode-go": {
+    label: "OpenCode Go",
+    // name 层兜底：host 规则覆盖直连（也覆盖手工配置的 anthropic 形态），但用户
+    // 经本地中转 / 自建网关（baseUrl 不是 opencode.ai）时 host 不匹配——只要名字
+    // 还认得出是 OpenCode Go，头就该照发。
+    wire: { userAgent: TIANSHU_USER_AGENT, sessionHeader: "x-opencode-session" },
+    notes: [
+      "No thinking block \u2014 reasoning arrives as reasoning_content with no params needed",
+      "reasoning_effort is accepted (low|medium|high|max|xhigh, all 200) and passed through verbatim",
+      "No cache support",
+      "Upstream requires x-opencode-session (stable per conversation) + a non-generic User-Agent; wire rules are host-keyed in HOST_WIRE_RULES"
+    ]
+  },
+  "opencode-go-anthropic": {
+    label: "OpenCode Go (Anthropic \u534F\u8BAE)",
+    wire: { userAgent: TIANSHU_USER_AGENT, sessionHeader: "x-opencode-session" },
+    notes: [
+      "Anthropic /v1/messages endpoint of the same upstream",
+      "Same session/UA requirements as opencode-go"
+    ]
+  },
+  openai: {
+    label: "OpenAI",
+    notes: [
+      "Partial-prefix cache with 128-token granularity",
+      "Ephemeral cache (5 min TTL)"
+    ]
+  },
+  codex: {
+    label: "Codex",
+    notes: [
+      "Uses Codex Responses API with OAuth authentication",
+      "Partial-prefix cache profile is provided by provider-profile.ts"
+    ]
+  },
+  claude: {
+    label: "Claude (Anthropic)",
+    notes: [
+      "Thinking block: {type: enabled} + budget_tokens",
+      "Reasoning effort via reasoning_effort parameter"
+    ]
+  },
+  longcat: {
+    label: "LongCat (Meituan)",
+    notes: [
+      "API supports only model/messages/stream/max_tokens/temperature/top_p \u2014 no response_format",
+      "Implicit server-side exact-prefix cache, cache hits free (official pricing)",
+      "JSON repair must run as plain-text re-ask (no json-mode)"
+    ]
+  },
+  ccswitch: {
+    label: "CC Switch",
+    notes: [
+      `\u672C\u5730 OpenAI \u517C\u5BB9\u4EE3\u7406\uFF0C\u9ED8\u8BA4 ${process.env.CC_SWITCH_PROXY_URL ?? "http://127.0.0.1:8891/v1"}`,
+      "\u8BA4\u8BC1\u4F7F\u7528 CC_SWITCH_PROXY_API_KEY \u73AF\u5883\u53D8\u91CF",
+      "\u6A21\u578B\u540D\u900F\u4F20\u2014\u2014\u53EF\u7528\u6A21\u578B\u53D6\u51B3\u4E8E cc-switch \u4FA7\u914D\u7F6E",
+      "\u26A0\uFE0F \u9884\u8BBE\u6A21\u578B\u5217\u8868\u4E3A\u79CD\u5B50\uFF0C\u4F7F\u7528\u524D\u786E\u8BA4\u6A21\u578B\u540D\u4E0E cc-switch \u4FA7\u4E00\u81F4\uFF0C\u5426\u5219\u4F1A 4xx",
+      "\u652F\u6301 reasoning_effort\uFF08OpenAI \u683C\u5F0F\uFF09\uFF0CRectifier \u5C42\u7FFB\u8BD1\u4E3A\u4E0A\u6E38\u539F\u751F\u63A8\u7406\u683C\u5F0F"
+    ]
+  },
+  siliconflow: {
+    label: "\u7845\u57FA\u6D41\u52A8 (SiliconFlow)",
+    notes: [
+      "\u805A\u5408\u7AD9\uFF1A\u591A\u6A21\u578B\u53EF\u9009\uFF08DeepSeek / GLM / Kimi / Qwen\uFF09",
+      "Thinking block: {type: enabled} + reasoning_effort\uFF08\u4E0A\u6E38\u652F\u6301\uFF09",
+      "\u670D\u52A1\u7AEF\u9690\u5F0F exact-prefix \u7F13\u5B58\uFF08DeepSeek-V4 / GLM-5.2 \u8BA1 Cached Input \u4EF7\uFF09",
+      "\u9ED8\u8BA4\u6A21\u578B\u662F DeepSeek \u4EE3\u7406 \u2192 \u6CBF\u7528 toolJsonBug \u6807\u8BB0"
+    ]
+  },
+  dashscope: {
+    label: "\u901A\u4E49\u5343\u95EE (DashScope)",
+    notes: [
+      "\u963F\u91CC DashScope\uFF1AQwen \u7CFB\u5217\u5B98\u65B9 OpenAI \u517C\u5BB9\u7AEF\u70B9",
+      "Thinking block: {type: enabled} + reasoning_effort\uFF08Qwen3-max \u652F\u6301\uFF09",
+      "\u6A21\u578B\u80FD\u529B\u5206\u88C2\uFF1AQwen-plus/turbo \u4E0D\u652F\u6301 thinking \u2192 \u7528 models[].capabilities override",
+      "\u4E0D\u652F\u6301 cache_control breakpoint\uFF08\u975E Anthropic \u534F\u8BAE\uFF09"
+    ]
+  },
+  openrouter: {
+    label: "OpenRouter",
+    notes: [
+      "\u56FD\u9645\u805A\u5408\uFF1AOpenAI / Claude / Gemini / \u5F00\u6E90\u6A21\u578B",
+      "thinking block \u900F\u4F20\u4E0D\u7A33\u5B9A \u2192 thinkingBlockType=none\uFF0C\u4EC5\u900F\u4F20 reasoning_effort",
+      "\u7528\u6237\u53EF\u6309\u9700\u5728 models[].capabilities \u91CC\u4E3A\u7279\u5B9A\u6A21\u578B\u5F00\u542F thinking"
+    ]
+  },
+  relay: {
+    label: "\u81EA\u5EFA\u4E2D\u8F6C (one-api / new-api)",
+    notes: [
+      "\u901A\u7528 OpenAI \u517C\u5BB9\u4E2D\u8F6C\u6A21\u677F\uFF08one-api / new-api / litellm \u7B49\uFF09",
+      "\u9ED8\u8BA4 config \u4E0D\u6FC0\u6D3B\u2014\u2014\u7528\u6237\u624B\u52A8\u542F\u7528\uFF0C\u907F\u514D\u548C ccswitch \u4F53\u9A8C\u91CD\u590D",
+      "baseUrl \u8D70 RELAY_BASE_URL \u73AF\u5883\u53D8\u91CF\uFF1B\u6A21\u578B\u5217\u8868\u6309\u9700\u586B\u5199",
+      "\u4E0E ccswitch \u540C\u6A21\u677F\uFF1Areasoning_effort \u900F\u4F20\uFF0CRectifier \u7FFB\u8BD1\u4E3A\u4E0A\u6E38\u539F\u751F\u683C\u5F0F"
+    ]
+  }
+};
+var HOST_WIRE_RULES = [
+  {
+    host: "opencode.ai",
+    wire: { userAgent: TIANSHU_USER_AGENT, sessionHeader: "x-opencode-session" }
+  }
+];
+function hostWireRule(baseUrl) {
+  if (!baseUrl) return void 0;
+  let host;
+  try {
+    host = new URL(baseUrl).hostname.toLowerCase().replace(/\.$/, "");
+  } catch {
+    return void 0;
+  }
+  return HOST_WIRE_RULES.find((r) => host === r.host || host.endsWith(`.${r.host}`))?.wire;
+}
+function resolveProviderWire(name, baseUrl) {
+  const byName = CATALOG_META[name]?.wire;
+  const byHost = hostWireRule(baseUrl);
+  if (!byName && !byHost) return void 0;
+  return { ...byHost, ...byName };
+}
+function buildEntry(key) {
+  const meta = CATALOG_META[key];
+  return {
+    key,
+    label: meta?.label ?? key,
+    // Live reference — capability data lives in provider.ts WELL_KNOWN_DEFAULTS.
+    capabilities: WELL_KNOWN_DEFAULTS[key],
+    wire: meta?.wire,
+    notes: meta?.notes ?? []
+  };
+}
+var PROVIDER_CATALOG = Object.fromEntries(
+  Object.keys(WELL_KNOWN_DEFAULTS).map((key) => [key, buildEntry(key)])
+);
+var providerEntrySchema = external_exports.object({
+  key: external_exports.string().min(1),
+  label: external_exports.string().min(1),
+  capabilities: external_exports.object({
+    supportsThinking: external_exports.boolean(),
+    thinkingBlockType: external_exports.enum(["enabled", "adaptive", "none"]),
+    preservedThinkingProtocol: external_exports.boolean().optional(),
+    reasoningSplit: external_exports.boolean().optional(),
+    thinkingBudgetField: external_exports.enum(["budget_tokens"]).optional(),
+    effortCap: external_exports.record(external_exports.string(), external_exports.string()).optional(),
+    supportsCacheControl: external_exports.boolean(),
+    stripParams: external_exports.array(external_exports.string()),
+    hasToolJsonInContentBug: external_exports.boolean(),
+    effortFormat: external_exports.enum(["reasoning_effort", "output_config", "none"]),
+    prefixCacheStrategy: external_exports.enum(["deepseek-native", "anthropic-cache-control", "none"]),
+    supportsResponseFormat: external_exports.boolean()
+  }),
+  cacheProfile: external_exports.object({
+    cacheType: external_exports.enum(["exact-prefix", "explicit-breakpoint", "partial-prefix", "block-kv", "none"]),
+    persistent: external_exports.boolean(),
+    minCacheTokens: external_exports.number().int().nonnegative(),
+    cacheGranularity: external_exports.number().int().positive().optional(),
+    ttlSeconds: external_exports.number().int().positive().optional()
+  }),
+  hasUsageMapping: external_exports.boolean(),
+  notes: external_exports.array(external_exports.string()).default([])
+});
+
+// src/api/caller-identity.ts
+init_esm_shims();
+import { randomUUID } from "crypto";
+var PROCESS_SESSION_ID = `tianshu-${randomUUID()}`;
+function callerIdentityHeaders(wire, sessionId) {
+  const headers = {};
+  if (wire?.userAgent) headers["User-Agent"] = wire.userAgent;
+  if (wire?.sessionHeader) {
+    headers[wire.sessionHeader] = sessionId ?? PROCESS_SESSION_ID;
+  } else if (sessionId) {
+    headers["X-Request-Session"] = sessionId;
+  }
+  return headers;
+}
+function providerIdentityHeaders(providerName, baseUrl, sessionId) {
+  return callerIdentityHeaders(resolveProviderWire(providerName ?? "", baseUrl), sessionId);
+}
+
+// src/api/factory.ts
+function resolveApiKey(provider) {
+  const cred = { name: provider.name, keyRef: provider.keyRef, apiKey: provider.apiKey, apiKeyEnv: provider.apiKeyEnv };
+  const resolved = tryResolveCredentialKey(cred);
+  if (resolved !== void 0) return resolved;
+  if (isKeylessProviderEntry(provider.name, provider)) return "";
+  throw new Error(
+    `No API key configured for provider "${provider.name}". Set apiKey in config or the ${provider.apiKeyEnv ?? `${provider.name.toUpperCase()}_API_KEY`} environment variable.`
+  );
+}
+function tryResolveCredentialKey(cred) {
+  const { name, keyRef, apiKey, apiKeyEnv } = cred;
+  if (keyRef) {
+    const secret = readSecret(keyRef);
+    if (secret) return secret;
+  }
+  if (apiKey) return apiKey;
+  if (apiKeyEnv) {
+    const env2 = process.env[apiKeyEnv];
+    if (env2) return env2;
+  }
+  const env = process.env[`${name.toUpperCase()}_API_KEY`];
+  if (env) return env;
+  return void 0;
+}
+function resolveCredentialKey(cred) {
+  const resolved = tryResolveCredentialKey(cred);
+  if (resolved !== void 0) return resolved;
+  const defaultEnvVar = `${cred.name.toUpperCase()}_API_KEY`;
+  throw new Error(
+    `No API key configured for "${cred.name}". Set apiKey in config or the ${cred.apiKeyEnv ?? defaultEnvVar} environment variable.`
+  );
+}
+function createProviderClient(provider, capabilities, params) {
+  const wire = resolveProviderWire(provider.name, provider.baseUrl);
+  const explicitSessionId = params.sessionId?.trim() ? params.sessionId : void 0;
+  const sessionId = explicitSessionId ?? (wire?.sessionHeader ? PROCESS_SESSION_ID : void 0);
+  const proFactory = proRegistry.getClientFactory(provider.name);
+  if (proFactory) return proFactory(provider, capabilities, params);
+  if (provider.name === "codex" && provider.auth?.type === "oauth") {
+    return new CodexClient({
+      baseUrl: provider.baseUrl,
+      model: params.model,
+      maxTokens: params.maxTokens,
+      auth: params.auth,
+      maxRetries: provider.maxRetries,
+      retry: provider.retry
+    });
+  }
+  if (provider.protocol === "anthropic") {
+    const budgetMap = {
+      max: params.maxTokens,
+      high: Math.floor(params.maxTokens * 0.6),
+      medium: Math.floor(params.maxTokens * 0.3),
+      low: 8192
+    };
+    const thinkingBudget = params.reasoningEffort ? budgetMap[params.reasoningEffort] ?? Math.floor(params.maxTokens * 0.6) : void 0;
+    return new AnthropicClient({
+      baseUrl: provider.baseUrl,
+      apiKey: params.apiKey,
+      model: params.model,
+      maxTokens: params.maxTokens,
+      thinkingBudget,
+      requestTimeoutMs: provider.requestTimeoutMs,
+      maxRetries: provider.maxRetries,
+      retry: provider.retry,
+      temperature: provider.temperature,
+      proxy: provider.proxy,
+      userAgent: wire?.userAgent,
+      sessionId,
+      sessionHeader: wire?.sessionHeader
+    });
+  }
+  return new OpenAIClient({
+    // 用户在 Base URL 里粘贴 curl 全文（`…/v1/chat/completions`）或留个尾斜杠
+    // 是常态。发送路径拼的是 `${baseUrl}/chat/completions`，不归一化就会出现
+    // `…/chat/completions/chat/completions`（404）或 `…/v1//chat/completions`。
+    // 探测路径早就用 normalizeBaseUrl 挡了这一手（endpoint-map.ts），发送路径
+    // 漏了——症状于是固定为「连接测试通过、对话静默失败」。
+    // 仅 OpenAI 分支适用：AnthropicClient 自己补 `/v1/messages`，对它剥尾巴会
+    // 反造出 `/v1/v1/messages`——那是另一种错法，不在本处收口。
+    baseUrl: normalizeBaseUrl(provider.baseUrl),
+    apiKey: params.apiKey,
+    model: params.model,
+    maxTokens: params.maxTokens,
+    auth: params.auth,
+    thinking: provider.thinking,
+    thinkingStallTimeoutMs: provider.thinkingStallTimeoutMs ?? wire?.thinkingStallTimeoutMs,
+    firstByteTimeoutMs: provider.firstByteTimeoutMs,
+    // Advanced provider knobs and slow-thinking override are both runtime inputs.
+    requestTimeoutMs: provider.requestTimeoutMs,
+    maxRetries: provider.maxRetries,
+    retry: provider.retry,
+    temperature: provider.temperature,
+    proxy: provider.proxy,
+    slowThinking: provider.slowThinking,
+    thinkingBlockType: capabilities.thinkingBlockType,
+    reasoningSplit: capabilities.reasoningSplit,
+    thinkingBudgetField: capabilities.thinkingBudgetField,
+    effortCap: capabilities.effortCap,
+    effortFormat: capabilities.effortFormat,
+    reasoningEffort: params.reasoningEffort,
+    sessionId,
+    sessionHeader: wire?.sessionHeader,
+    providerName: provider.name,
+    // 401/403 报错里点名 key 的环境变量，用户知道去哪检查。
+    apiKeyEnv: provider.apiKeyEnv,
+    // Preserved-thinking protocol family: table-driven capability, not provider
+    // name — the pro spark preset declares it via capabilities override, so no
+    // pro provider name leaks into open-source wire code. Distinct from the
+    // deepseek-native prefix-cache strategy (GLM/longcat share the cache
+    // strategy but have independent reasoning — they must NOT get this).
+    preservedThinkingProtocol: capabilities.preservedThinkingProtocol ?? false,
+    providerProfile: getProviderProfile(provider.name, modelContextWindow(provider, params.model)),
+    wireContext: params.wireContext,
+    unsupported: provider.unsupported.length > 0 ? provider.unsupported : capabilities.stripParams,
+    prefixCompletion: provider.capabilities.prefixCompletion,
+    useMaxCompletionTokens: wire?.useMaxCompletionTokens,
+    userAgent: wire?.userAgent,
+    usageCalibrationFactor: provider.usageCalibrationFactor,
+    capabilities: { hasToolJsonInContentBug: capabilities.hasToolJsonInContentBug }
+  });
+}
+function modelContextWindow(provider, modelId) {
+  const pool = contractModels(provider);
+  return pool.find((model) => model.id === modelId)?.contextWindow ?? pool[0]?.contextWindow ?? 128e3;
+}
+
+export {
+  fetchWithTimeout,
+  REASONING_FIRST_BYTE_TIMEOUT_MS,
+  SLOW_FIRST_BYTE_TIMEOUT_MS,
+  FIRST_BYTE_PER_100K_MS,
+  isSlowThinkingProvider,
+  resolveCapabilities,
+  providerIdentityHeaders,
+  resolveApiKey,
+  tryResolveCredentialKey,
+  resolveCredentialKey,
+  createProviderClient
+};