@bitkyc08/opencodex 2.63.0 → 2.64.0

package/src/adapters/cursor/request-builder.ts

@@ -209,8 +209,9 @@ export function cursorRequestEmitsFastVariant(parsed: OcxParsedRequest): boolean
 
 /**
  * Resolve a `cursor/<model>` selection + Codex reasoning effort to Cursor's requested model shape.
- * Most models encode effort in a flat id (`claude-4.6-opus-high`). Grok Fast is parameterized
- * instead: current Cursor clients send the matching Grok base id plus `effort` and `fast` parameters.
+ * Most models encode effort in a flat id (`claude-4.6-opus-high`). Grok 4.5/4.6 Fast is
+ * parameterized: current Cursor clients send the matching base id plus `effort` and `fast` parameters;
+ * Grok 4.7 (no wirePrefix) instead uses the flattened effort-fast id.
  * A fully-qualified id (one that is not a known effort base) passes through unchanged.
  */
 function normalizeCursorModelId(modelId: string, reasoning?: string, fast?: boolean, liveRosterScope?: string): {
@@ -226,8 +227,8 @@ function normalizeCursorModelId(modelId: string, reasoning?: string, fast?: bool
   // resolver owns effort composition, variant dimensions, the synthetic -1m
   // marker (ultra -> Max Mode, evidence-gated), and the cursor- wire prefix.
   const id = selection.modelId;
-  // Grok Fast stays parameterized: current Cursor clients send the base id
-  // plus effort/fast parameters instead of the flattened -fast id.
+  // Grok 4.5/4.6 Fast stays parameterized: current Cursor clients send the base id
+  // plus effort/fast parameters; 4.7 (no wirePrefix) uses the flattened effort-fast id.
   const grokFast = cursorGrokFastSelection(id, reasoning, fast);
   if (grokFast) {
     return {

package/src/adapters/cursor/tool-guidance.ts

@@ -185,7 +185,7 @@ export function buildCursorToolGuidanceSystemNote(
     // Code mode: shell/edit/MCP live inside freeform `exec` as nested helpers. Without this the
     // model probes for a top-level shell tool that is not there.
     codeMode
-      ? `\`${CODEX_UNIFIED_EXEC_TOOL}\` is Codex code mode: its body is JavaScript evaluated in a V8 isolate, not a shell command and not Node. Shell, file edits, and MCP are nested helpers called INSIDE that body as \`await tools.<name>(...)\`, for example \`await tools.exec_command({cmd: \"ls\"})\`. Read the tool description and the isolate global \`ALL_TOOLS\` (not \`tools.ALL_TOOLS\`) for helpers this turn provides; absence from the top-level catalog or from \`exec\`'s description is not absence. Those nested helpers are not themselves top-level tools, so do not call \`exec_command\` or \`shell_command\` at the top level here${codeModeOtherTopLevelNames.length > 0 ? `; every other tool this turn lists, including ${quotedNames(codeModeOtherTopLevelNames)}, remains callable at the top level as usual` : ""}. Nested \`tools.apply_patch(input)\` is host-executed: the string must begin exactly with \`*** Begin Patch\` and end with \`*** End Patch\`, each marker line being three asterisks, one space, the two words, then end of line with no further asterisks. OpenCodex does not rewrite JavaScript inside exec, so extra asterisks on a marker line are rejected by Codex before the file is touched.`
+      ? `\`${CODEX_UNIFIED_EXEC_TOOL}\` is Codex code mode: its body is JavaScript evaluated in a V8 isolate, not a shell command and not Node. Shell, file edits, and MCP are nested helpers called INSIDE that body as \`await tools.<name>(...)\`, for example \`text(await tools.exec_command({cmd: \"ls\"}))\`. Read the tool description and the isolate global \`ALL_TOOLS\` (not \`tools.ALL_TOOLS\`) for helpers this turn provides; absence from the top-level catalog or from \`exec\`'s description is not absence. Those nested helpers are not themselves top-level tools, so do not call \`exec_command\` or \`shell_command\` at the top level here${codeModeOtherTopLevelNames.length > 0 ? `; every other tool this turn lists, including ${quotedNames(codeModeOtherTopLevelNames)}, remains callable at the top level as usual` : ""}. Nested \`tools.apply_patch(input)\` is host-executed: the string must begin exactly with \`*** Begin Patch\` and end with \`*** End Patch\`, each marker line being three asterisks, one space, the two words, then end of line with no further asterisks. OpenCodex does not rewrite JavaScript inside exec, so extra asterisks on a marker line are rejected by Codex before the file is touched.`
       : undefined,
     codeMode
       ? CODE_MODE_RESULT_ECHO_SENTENCE + " There is no `require`, no `module`, and no filesystem or network globals; reach the host only through the nested helpers. " + CODE_MODE_HOST_CONTRACT_SENTENCE

package/src/adapters/devin/live-models.ts

@@ -30,6 +30,7 @@ export const DEVIN_STATIC_MODELS = [
   "glm-5-2",
   "kimi-k2-7",
   "grok-4-5",
+  "grok-4-7",
 ] as const;
 
 /**
@@ -73,6 +74,9 @@ export const DEVIN_MODEL_CONTEXT_WINDOWS: Record<string, number> = {
   "gemini-3-8-flash": 1_048_576,
   "grok-4-5": 500_000,
   "grok-4-6": 500_000,
+  // Live Devin catalog context_length, 2026-09-23:
+  // devlog/_plan/260923_grok47_parity/010_probe-evidence.md.
+  "grok-4-7": 500_000,
 };
 
 /**
@@ -135,6 +139,9 @@ export function sortDevinRungs(rungs: Iterable<string>): string[] {
  */
 export const DEVIN_MODEL_EFFORTS: Record<string, string[]> = {
   "swe-2": ["medium", "high", "max"],
+  // Live Devin catalog, 2026-09-23:
+  // devlog/_plan/260923_grok47_parity/010_probe-evidence.md.
+  "grok-4-7": ["low", "medium", "high", "xhigh", "max"],
 };
 
 /**

package/src/adapters/inline-think-tags.ts

@@ -0,0 +1,251 @@
+import type { AdapterEvent } from "../types";
+import { modelInList } from "../types";
+import type { TranslatorBudget } from "../lib/translator-budget";
+
+type ThinkingTag = "<thinking>" | "<think>" | "<reasoning>";
+type ParserState = "pre" | "thinking" | "scanning" | "streaming";
+
+const OPEN_TAGS: ThinkingTag[] = ["<thinking>", "<think>", "<reasoning>"];
+const MAX_OPEN_TAG = Math.max(...OPEN_TAGS.map(t => t.length));
+const MAX_CLOSE_TAG = Math.max(...OPEN_TAGS.map(t => `</${t.slice(1)}`.length));
+
+function closeTagFor(openTag: ThinkingTag): string {
+  return `</${openTag.slice(1)}`;
+}
+
+function isPossibleOpenTagPrefix(text: string): boolean {
+  return OPEN_TAGS.some(tag => tag.startsWith(text) && text.length < tag.length);
+}
+
+/** Move a send boundary back one unit rather than splitting a surrogate pair into U+FFFD. */
+function surrogateSafeCut(text: string, cut: number): number {
+  if (cut <= 0 || cut >= text.length) return Math.max(0, Math.min(cut, text.length));
+  const atCut = text.charCodeAt(cut - 1);
+  return atCut >= 0xd800 && atCut <= 0xdbff ? cut - 1 : cut;
+}
+
+export interface InlineThinkTagOptions {
+  /**
+   * Keep scanning for further think blocks after the first one closes. Kiro emits a single
+   * leading block, so it leaves this off and streams the rest verbatim. MiniMax M-series
+   * interleaves several blocks with answer segments, so a reusing adapter opts in.
+   */
+  interleaved?: boolean;
+}
+
+/**
+ * Recovers thinking that a gateway left inline in visible content as `<think>` blocks instead of
+ * a separate `reasoning_content` / `reasoning_details` field. Shared by the Kiro adapter and by
+ * the openai-chat adapter's opt-in `inlineThinkTagModels`.
+ */
+export class InlineThinkTagParser {
+  private state: ParserState = "pre";
+  private preWhitespaceChunks: string[] = [];
+  private preWhitespaceLength = 0;
+  private preWhitespaceBytes = 0;
+  private preBuffer = "";
+  private thinkingBuffer = "";
+  private closeTag = "";
+
+  private readonly interleaved: boolean;
+
+  constructor(private readonly budget?: TranslatorBudget, options?: InlineThinkTagOptions) {
+    this.interleaved = options?.interleaved === true;
+  }
+
+  private replaceCarry(field: "preBuffer" | "thinkingBuffer", next: string): void {
+    const previous = this[field];
+    if (previous === next) return;
+    const previousBytes = Buffer.byteLength(previous);
+    const nextBytes = Buffer.byteLength(next);
+    const reservation = this.budget?.reserveTransient(nextBytes, { kind: "reasoning" });
+    this[field] = next;
+    reservation?.commitRetained();
+    this.budget?.releaseRetained(previousBytes, { kind: "reasoning" });
+  }
+
+  private appendPreWhitespace(text: string): void {
+    if (!text) return;
+    const bytes = Buffer.byteLength(text);
+    const reservation = this.budget?.reserveTransient(bytes, { kind: "reasoning" });
+    this.preWhitespaceChunks.push(text);
+    this.preWhitespaceLength += text.length;
+    this.preWhitespaceBytes += bytes;
+    reservation?.commitRetained();
+  }
+
+  private finishPreWhitespace(emit: boolean): string {
+    if (this.preWhitespaceLength === 0) return "";
+    const reservation = emit ? this.budget?.reserveTransient(this.preWhitespaceBytes, { kind: "reasoning" }) : undefined;
+    try {
+      return emit ? this.preWhitespaceChunks.join("") : "";
+    } finally {
+      this.preWhitespaceChunks.length = 0;
+      this.preWhitespaceLength = 0;
+      this.budget?.releaseRetained(this.preWhitespaceBytes, { kind: "reasoning" });
+      this.preWhitespaceBytes = 0;
+      reservation?.release();
+    }
+  }
+
+  feed(text: string): AdapterEvent[] {
+    if (!text) return [];
+    if (this.state === "streaming") return [{ type: "text_delta", text }];
+    let input = text;
+    if (this.state === "pre") {
+      if (this.preBuffer) {
+        input = this.preBuffer + text;
+        this.replaceCarry("preBuffer", "");
+      } else {
+        const stripped = text.trimStart();
+        const leadingLength = text.length - stripped.length;
+        if (leadingLength > 0) this.appendPreWhitespace(text.slice(0, leadingLength));
+        if (!stripped) return [];
+        input = stripped;
+      }
+      const openTag = OPEN_TAGS.find(tag => input.startsWith(tag));
+      if (openTag) {
+        const leading = this.finishPreWhitespace(this.interleaved);
+        this.state = "thinking";
+        this.closeTag = closeTagFor(openTag);
+        const events: AdapterEvent[] = leading ? [{ type: "text_delta", text: leading }] : [];
+        return this.drainChunk(input, openTag.length, events);
+      }
+      if (input.length <= MAX_OPEN_TAG && isPossibleOpenTagPrefix(input)) {
+        this.replaceCarry("preBuffer", input);
+        return [];
+      }
+      this.state = "streaming";
+      return [{ type: "text_delta", text: this.finishPreWhitespace(true) + input }];
+    }
+    if (this.state === "thinking") {
+      input = this.thinkingBuffer + text;
+      this.replaceCarry("thinkingBuffer", "");
+    } else {
+      input = this.preBuffer + text;
+      this.replaceCarry("preBuffer", "");
+    }
+    return this.drainChunk(input, 0, []);
+  }
+
+  flush(): AdapterEvent[] {
+    if (this.state === "thinking") {
+      const out = this.thinkingBuffer;
+      this.replaceCarry("thinkingBuffer", "");
+      this.state = "streaming";
+      return out ? [{ type: "reasoning_raw_delta", text: out }] : [];
+    }
+    if (this.preWhitespaceLength > 0 || this.preBuffer) {
+      const out = this.finishPreWhitespace(true) + this.preBuffer;
+      this.replaceCarry("preBuffer", "");
+      this.state = "streaming";
+      return [{ type: "text_delta", text: out }];
+    }
+    return [];
+  }
+
+  /** Release any partial tag/content carry when the owning stream stops early. */
+  dispose(): void {
+    this.finishPreWhitespace(false);
+    this.replaceCarry("preBuffer", "");
+    this.replaceCarry("thinkingBuffer", "");
+    this.closeTag = "";
+    this.state = "streaming";
+  }
+
+  private drainChunk(input: string, start: number, events: AdapterEvent[]): AdapterEvent[] {
+    let offset = start;
+    for (;;) {
+      if (this.state === "thinking") {
+        const idx = input.indexOf(this.closeTag, offset);
+        if (idx >= 0) {
+          if (idx > offset) events.push({ type: "reasoning_raw_delta", text: input.slice(offset, idx) });
+          offset = idx + this.closeTag.length;
+          if (!this.interleaved) {
+            // Opt-in Chat answers are byte-preserving; keep Kiro's legacy normalization.
+            const after = input.slice(offset).trimStart();
+            this.state = "streaming";
+            if (after) events.push({ type: "text_delta", text: after });
+            return events;
+          }
+          this.state = "scanning";
+          continue;
+        }
+        // Keep only a possible close tag, and do not split a surrogate pair.
+        const cut = Math.max(offset, surrogateSafeCut(input, input.length - MAX_CLOSE_TAG));
+        if (cut > offset) events.push({ type: "reasoning_raw_delta", text: input.slice(offset, cut) });
+        this.replaceCarry("thinkingBuffer", input.slice(cut));
+        return events;
+      }
+
+      // Interleaved mode has already seen a leading tag; later tags delimit anywhere.
+      let openIndex = input.indexOf("<", offset);
+      let openTag: ThinkingTag | undefined;
+      while (openIndex >= 0) {
+        openTag = OPEN_TAGS.find(tag => input.startsWith(tag, openIndex));
+        if (openTag) break;
+        openIndex = input.indexOf("<", openIndex + 1);
+      }
+      if (openIndex >= 0 && openTag) {
+        if (openIndex > offset) events.push({ type: "text_delta", text: input.slice(offset, openIndex) });
+        offset = openIndex + openTag.length;
+        this.state = "thinking";
+        this.closeTag = closeTagFor(openTag);
+        continue;
+      }
+      // Hold back only a possible open-tag prefix, with a surrogate-safe boundary.
+      const cut = Math.max(offset, surrogateSafeCut(input, input.length - (MAX_OPEN_TAG - 1)));
+      if (cut > offset) events.push({ type: "text_delta", text: input.slice(offset, cut) });
+      this.replaceCarry("preBuffer", input.slice(cut));
+      return events;
+    }
+  }
+}
+
+/** Visible-content splitter the openai-chat adapter holds for the life of one response. */
+export interface InlineThinkContentSplitter {
+  feed(text: string): AdapterEvent[];
+  flush(): AdapterEvent[];
+  dispose(): void;
+}
+
+const PASSTHROUGH: InlineThinkContentSplitter = {
+  feed: text => [{ type: "text_delta", text }],
+  flush: () => [],
+  dispose: () => { /* nothing carried */ },
+};
+
+/**
+ * Opt-in recovery for `inlineThinkTagModels`. A model that is not listed gets a passthrough that
+ * never inspects or rewrites visible content, so the 66 registry providers sharing the openai-chat
+ * adapter keep byte-exact behavior.
+ */
+export function createInlineThinkContentSplitter(
+  models: string[] | undefined,
+  modelId: string | undefined,
+  budget?: TranslatorBudget,
+): InlineThinkContentSplitter {
+  if (!modelInList(models, modelId ?? "")) return PASSTHROUGH;
+  const parser = new InlineThinkTagParser(budget, { interleaved: true });
+  return {
+    // An empty content delta stays an empty delta: it is a wire signal, not thinking.
+    feed: text => (text.length === 0 ? [{ type: "text_delta", text }] : parser.feed(text)),
+    flush: () => parser.flush(),
+    dispose: () => parser.dispose(),
+  };
+}
+
+/** One-shot form for a non-streaming response body. */
+export function splitInlineThinkContent(
+  models: string[] | undefined,
+  modelId: string | undefined,
+  budget: TranslatorBudget | undefined,
+  content: string,
+): AdapterEvent[] {
+  const splitter = createInlineThinkContentSplitter(models, modelId, budget);
+  try {
+    return [...splitter.feed(content), ...splitter.flush()];
+  } finally {
+    splitter.dispose();
+  }
+}

package/src/adapters/kiro/adapter.ts

@@ -250,6 +250,7 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
       });
       return {
         response,
+        abortSignal: requestAbortSignal,
         inputTokens: retry.inputTokens,
         contextInputEstimate: retry.contextInputEstimate,
         nameMap: retry.nameMap,

package/src/adapters/kiro/stream.ts

@@ -16,9 +16,10 @@ import {
 } from "../kiro-errors";
 import { parseKiroEvent } from "../kiro-events";
 import { noteKiroTransientThrottle } from "../kiro-retry";
-import { KiroThinkingParser } from "../kiro-thinking";
+import { InlineThinkTagParser } from "../inline-think-tags";
 import { isCompleteKiroToolInput, kiroTruncationErrorMessage } from "../kiro-truncation";
 import { isValidKiroConversationId } from "../kiro-wire";
+import { readDisplaySafeErrorPayloadText } from "../upstream-http-error";
 import { tagKiroReasoningBlob } from "./reasoning";
 import { estimateKiroTokens, kiroUpstreamContextWindow } from "./usage";
 
@@ -74,6 +75,7 @@ function createKiroAttemptRetention(budget: TranslatorBudget): KiroAttemptRetent
 
 interface KiroFallbackAttempt {
   response: Response;
+  abortSignal?: AbortSignal;
   inputTokens: number;
   contextInputEstimate: number;
   nameMap: Map<string, string>;
@@ -319,7 +321,7 @@ async function* parseKiroAttemptEvents(
   let authoritativeUsage: OcxUsage | undefined;
   let stopReason: string | undefined;
   const fallbackEvents: AdapterEvent[] = [];
-  const thinking = new KiroThinkingParser(budget);
+  const thinking = new InlineThinkTagParser(budget);
 
   const retainedEventBytes = (event: AdapterEvent): number => Buffer.byteLength(JSON.stringify(event));
   const retainEvent = (event: AdapterEvent): void => {
@@ -1092,7 +1094,7 @@ export async function* parseKiroStream(
     firstResult.releaseRetained();
     fallback.releaseRequestBody?.();
     if (!fallback.response.ok) {
-      const payload = await fallback.response.text().catch(() => "");
+      const payload = await readDisplaySafeErrorPayloadText(fallback.response, fallback.abortSignal);
       const failure = classifyKiroHttpError(fallback.response.status, fallback.response.headers, payload);
       yield {
         type: "error",

package/src/adapters/kiro/usage.ts

@@ -1,4 +1,4 @@
-import { estimateTokens } from "../../lib/token-estimate";
+import { estimateTokens, estimateTokensFromCharacterCounts } from "../../lib/token-estimate";
 import { KIRO_MODEL_CONTEXT_WINDOWS, normalizeKiroModelId } from "../../providers/kiro-models";
 import { modelRecordValue } from "../../reasoning-effort";
 import { sniffImageDimensions } from "../anthropic-image-guard";
@@ -98,8 +98,9 @@ export function estimateKiroWireTokens(text: string, modelId: string): number {
   if (!text) return 0;
   const cjk = kiroCjkCount(text);
   if (cjk === 0) return Math.ceil(estimateKiroTokens(text, modelId) * KIRO_LATIN_WIRE_EXPANSION);
-  const latinTokens = estimateKiroTokens("x".repeat(text.length - cjk), modelId);
-  const cjkTokens = estimateKiroTokens("\uac00".repeat(cjk), modelId);
+  const prefixedModelId = `kiro/${modelId}`;
+  const latinTokens = estimateTokensFromCharacterCounts(text.length - cjk, 0, prefixedModelId);
+  const cjkTokens = estimateTokensFromCharacterCounts(0, cjk, prefixedModelId);
   return Math.ceil(latinTokens * KIRO_LATIN_WIRE_EXPANSION + cjkTokens);
 }
 

package/src/adapters/mimo-free.ts

@@ -105,11 +105,10 @@ export function resetMimoJwtCache(): void {
   inFlightJwt = null;
 }
 
-async function fetchJwt(signal?: AbortSignal): Promise<string> {
-  // Bounded bootstrap: request-abort propagates, and a stalled bootstrap can never
-  // hang past BOOTSTRAP_TIMEOUT_MS.
+async function fetchJwt(): Promise<string> {
+  // Bounded bootstrap: a stalled bootstrap can never hang past BOOTSTRAP_TIMEOUT_MS. It carries
+  // no caller signal because concurrent requests share it; each caller aborts its own wait.
   const timeout = AbortSignal.timeout(BOOTSTRAP_TIMEOUT_MS);
-  const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
   const response = await fetch(BOOTSTRAP_URL, {
     method: "POST",
     redirect: "manual",
@@ -118,7 +117,7 @@ async function fetchJwt(signal?: AbortSignal): Promise<string> {
       "User-Agent": randomUserAgent(),
     },
     body: JSON.stringify({ client: getMimoClientId() }),
-    signal: combined,
+    signal: timeout,
   });
   if (!response.ok) {
     try { await response.body?.cancel(); } catch { /* already consumed */ }
@@ -159,25 +158,45 @@ async function fetchJwt(signal?: AbortSignal): Promise<string> {
   return data.jwt;
 }
 
+function abortReason(signal: AbortSignal): unknown {
+  return signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
+}
+
+/** Wait for the shared bootstrap, or stop waiting when this caller aborts; the bootstrap keeps running. */
+function awaitForCaller(shared: Promise<string>, signal?: AbortSignal): Promise<string> {
+  if (!signal) return shared;
+  if (signal.aborted) return Promise.reject(abortReason(signal));
+  return new Promise<string>((resolve, reject) => {
+    const onAbort = () => reject(abortReason(signal));
+    signal.addEventListener("abort", onAbort, { once: true });
+    shared.then(
+      jwt => { signal.removeEventListener("abort", onAbort); resolve(jwt); },
+      error => { signal.removeEventListener("abort", onAbort); reject(error); },
+    );
+  });
+}
+
 export async function getMimoJwt(signal?: AbortSignal): Promise<string> {
   if (cachedJwt && Date.now() < jwtExpiresAt - JWT_EXPIRY_BUFFER_MS) {
     return cachedJwt;
   }
+  if (signal?.aborted) throw abortReason(signal);
   // Single-flight: concurrent callers await the same bootstrap instead of issuing
-  // parallel bootstraps.
+  // parallel bootstraps. One caller aborting must not fail the others, so the shared
+  // bootstrap is bound only to its timeout and each caller races it against its own signal.
   if (!inFlightJwt) {
-    inFlightJwt = (async () => {
-      try {
-        const jwt = await fetchJwt(signal);
-        cachedJwt = jwt;
-        jwtExpiresAt = parseJwtExp(jwt);
-        return jwt;
-      } finally {
-        inFlightJwt = null;
-      }
-    })();
+    const shared = fetchJwt().then(jwt => {
+      cachedJwt = jwt;
+      jwtExpiresAt = parseJwtExp(jwt);
+      return jwt;
+    });
+    inFlightJwt = shared;
+    // Registered before any waiter, so the slot is cleared first; it also handles a failure that
+    // arrives after every waiter has left. A reset during the flight owns the slot and is kept.
+    const release = () => { if (inFlightJwt === shared) inFlightJwt = null; };
+    shared.then(release, release);
   }
-  return inFlightJwt;
+  return awaitForCaller(inFlightJwt, signal);
 }
 
 /**
@@ -223,7 +242,7 @@ export function createMimoFreeAdapter(provider: OcxProviderConfig): ProviderAdap
     name: "mimo-free",
 
     async buildRequest(parsed: OcxParsedRequest, incoming: IncomingMeta): Promise<AdapterRequest> {
-      const jwt = await getMimoJwt();
+      const jwt = await getMimoJwt(incoming?.abortSignal);
 
       // Let the base adapter build the wire body (handles reasoning, tools, etc.)
       // but override the URL and headers after.

package/src/adapters/openai-chat/messages.ts

@@ -224,7 +224,7 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
         let reasoningContent = thinkingParts.map(p => p.thinking).join("");
         if (
           reasoningContent.length === 0
-          && toolCalls.length > 0
+          && (toolCalls.length > 0 || thinkingParts.length > 0)
           && modelInList(provider.preserveReasoningContentModels, parsed.modelId)
         ) {
           const cached = toolCalls
@@ -235,11 +235,11 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
           if (cached.length > 0) {
             reasoningContent = [...new Set(cached)].join("\n");
           } else if (modelInList(provider.requiresReasoningPlaceholderModels ?? provider.preserveReasoningContentModels, parsed.modelId)) {
-            // Fallback (extends #950, closes #1193): the replay cache is
+            // Fallback (extends #950 and #1193; fixes #5421): the replay cache is
             // bounded (64 entries / 256 KiB / 1 h TTL) and always misses on
-            // long sessions, and some tool rounds carry no recorded reasoning
-            // at all. DeepSeek thinking mode rejects ANY tool_call assistant
-            // message missing reasoning_content with HTTP 400, so inject a
+            // long sessions, and some thinking/tool rounds carry no recorded
+            // reasoning at all. DeepSeek thinking mode rejects replay without
+            // reasoning_content with HTTP 400, so inject a
             // minimal placeholder rather than emit a bare continuation the
             // upstream will reject. Scoped to requiresReasoningPlaceholderModels
             // (defaulting to the preserve list): preserve-listed providers with