@bitkyc08/opencodex 2.84.0 → 2.87.0

package/src/adapters/cursor/protobuf-events.ts

@@ -2,6 +2,7 @@ import type { OcxUsage } from "../../types";
 import type { AgentServerMessage, McpArgs, ToolCall } from "./gen/agent_pb";
 import { decodeCursorArgsMap } from "./arg-codec";
 import { normalizeArgKeys } from "./arg-normalize";
+import { canonicalCursorFreeformArgs } from "./freeform-args";
 import {
   CODEX_APPLY_PATCH_TOOL,
   CURSOR_MULTI_EDIT_TOOL,
@@ -334,9 +335,20 @@ function toolSchemaForWireName(state: CursorProtobufEventState, toolName: string
   return resolveShellBridgeAliasKey(toolName, alias => state.toolSchemas!.get(alias));
 }
 
-function decodeMcpArgsNormalized(args: McpArgs | undefined, state: CursorProtobufEventState): string {
-  const decoded = decodeCursorArgsMap(args?.args);
+function isFreeformCall(state: CursorProtobufEventState, responsesName: string | undefined): boolean {
+  return responsesName !== undefined && state.freeformToolNames?.has(responsesName) === true;
+}
+
+function decodeMcpArgsNormalized(
+  args: McpArgs | undefined,
+  state: CursorProtobufEventState,
+  openResponsesName?: string,
+): string {
   const toolName = mcpWireNameFromArgs(args);
+  const responsesName = toolName
+    ? responsesToolNameFromCursorWire(toolName, state.cursorToolNameMap)
+    : openResponsesName;
+  const decoded = decodeCursorArgsMap(args?.args, { preserveStrings: isFreeformCall(state, responsesName) });
   const schema = toolSchemaForWireName(state, toolName);
   if (schema) return JSON.stringify(normalizeArgKeys(decoded, schema));
   return JSON.stringify(decoded);
@@ -381,8 +393,13 @@ function normalizeJsonText(text: string, toolName: string | undefined, state: Cu
  * preserved verbatim so the bridge can reject malformed or truncated JSON instead of silently
  * converting it to `{}`. A genuinely empty buffer remains the no-argument case.
  */
-function resolveCompletedArgs(buffered: string, args: McpArgs | undefined, state: CursorProtobufEventState): string {
-  if (hasMcpArgBytes(args)) return decodeMcpArgsNormalized(args, state);
+function resolveCompletedArgs(
+  buffered: string,
+  args: McpArgs | undefined,
+  state: CursorProtobufEventState,
+  openResponsesName?: string,
+): string {
+  if (hasMcpArgBytes(args)) return decodeMcpArgsNormalized(args, state, openResponsesName);
   const name = mcpWireNameFromArgs(args);
   if (isCompleteJson(buffered)) return normalizeJsonText(buffered, name, state);
   return buffered;
@@ -1092,7 +1109,7 @@ export function mapSyntheticMcpExecToToolEvents(
     const out: CursorServerMessage[] = [...recordToolCall(options.state, callId, cursorWireName)];
     if (out.some(event => event.type === "error")) return out;
     const open = options.state.openToolCalls.get(callId);
-    const finalArgs = resolveCompletedArgs(open?.args ?? "", args, options.state);
+    const finalArgs = resolveCompletedArgs(open?.args ?? "", args, options.state, open?.name);
     out.push(...commitToolCall(options.state, callId, finalArgs));
     return out;
   }
@@ -1167,23 +1184,16 @@ function discardBufferedTextToolCalls(state: CursorProtobufEventState): void {
  * recorded in `openToolCalls`. Because each completion emits a whole non-interleaved unit, the bridge
  * (which tracks a single current tool call) serializes parallel Cursor calls correctly.
  */
-function cursorFreeformWrapperValid(args: string): boolean {
-  try {
-    const parsed = JSON.parse(args) as unknown;
-    return !!parsed
-      && typeof parsed === "object"
-      && !Array.isArray(parsed)
-      && typeof (parsed as Record<string, unknown>).input === "string";
-  } catch {
-    return false;
-  }
+/** True when the args already carry a body this call can commit, canonical or repairable (#7049). */
+function cursorFreeformArgsCommittable(args: string, toolName: string): boolean {
+  return canonicalCursorFreeformArgs(args, toolName).ok;
 }
 
-function dropInvalidFreeformCall(state: CursorProtobufEventState, callId: string, toolName: string): CursorServerMessage[] {
+function dropInvalidFreeformCall(state: CursorProtobufEventState, callId: string, toolName: string, reason: string): CursorServerMessage[] {
   state.openToolCalls.delete(callId);
   state.translatorBudget?.closeCall(callId);
   state.completedToolCalls.add(callId);
-  return [{ type: "error", message: `${toolName} call had invalid freeform arguments; expected {input:string}` }];
+  return [{ type: "error", message: `${toolName} call had invalid freeform arguments; expected {input:string} (${reason})` }];
 }
 
 function dropShellBridgeCall(state: CursorProtobufEventState, callId: string, toolName: string): CursorServerMessage[] {
@@ -1202,11 +1212,14 @@ function dropStructuredEditCall(state: CursorProtobufEventState, callId: string,
   return [{ type: "text", text: `\n${toolName} call was not converted to apply_patch: ${reason}` }];
 }
 
-function commitToolCall(state: CursorProtobufEventState, callId: string, finalArgs: string): CursorServerMessage[] {
+function commitToolCall(state: CursorProtobufEventState, callId: string, committedArgs: string): CursorServerMessage[] {
   const open = state.openToolCalls.get(callId);
   if (!open) return [];
-  if (state.freeformToolNames?.has(open.name) && !cursorFreeformWrapperValid(finalArgs)) {
-    return dropInvalidFreeformCall(state, callId, open.name);
+  let finalArgs = committedArgs;
+  if (isFreeformCall(state, open.name)) {
+    const freeform = canonicalCursorFreeformArgs(finalArgs, open.name);
+    if (!freeform.ok) return dropInvalidFreeformCall(state, callId, open.name, freeform.reason);
+    finalArgs = freeform.args;
   }
   const schema = toolSchemaForWireName(state, open.name);
   if (!cursorShellBridgeArgsValid(finalArgs, open.name, schema)) {
@@ -1386,7 +1399,7 @@ export function mapCursorProtobufServerMessage(
         && (
           (name !== undefined && openBeforeStart.args.length === 0)
           || (state.freeformToolNames?.has(openBeforeStart.name) === true
-            && !cursorFreeformWrapperValid(openBeforeStart.args)
+            && !cursorFreeformArgsCommittable(openBeforeStart.args, openBeforeStart.name)
           )
         )
       ) {
@@ -1410,13 +1423,13 @@ export function mapCursorProtobufServerMessage(
       if (
         !openBeforeStart && open && !hasMcpArgBytes(args)
         && state.freeformToolNames?.has(open.name) === true
-        && !cursorFreeformWrapperValid(open.args)
+        && !cursorFreeformArgsCommittable(open.args, open.name)
       ) {
         open.awaitingNativeArgs = true;
         return [];
       }
       if (open) {
-        const finalArgs = resolveCompletedArgs(open.args, args, state);
+        const finalArgs = resolveCompletedArgs(open.args, args, state, open.name);
         out.push(...commitToolCall(state, update.value.callId, finalArgs));
       }
       return out;

package/src/adapters/dsh-account.ts

@@ -0,0 +1,97 @@
+import type { IncomingMeta, ProviderAdapter } from "./base";
+import { createAnthropicAdapter } from "./anthropic";
+import type { AdapterFactoryContext } from "./registry";
+import type { OcxParsedRequest, OcxProviderConfig } from "../types";
+import { resolveDshAccountMessagesUrl } from "../providers/dsh-account-destination";
+
+export { DSH_ACCOUNT_DEFAULT_MESSAGES_URL, resolveDshAccountMessagesUrl } from "../providers/dsh-account-destination";
+
+export const DSH_ACCOUNT_RESERVED_HEADERS = new Set([
+  "x-dsh-auth-token",
+  "anthropic-version",
+  "authorization",
+  "x-api-key",
+  "host",
+]);
+
+export function createDshAccountAdapter(
+  provider: OcxProviderConfig,
+  _context?: AdapterFactoryContext,
+): ProviderAdapter {
+  // Use key authMode internally so that createAnthropicAdapter doesn't inject Claude Code headers/prompt.
+  const baseAdapter = createAnthropicAdapter({
+    ...provider,
+    authMode: "key",
+  }, "none");
+
+  return {
+    ...baseAdapter,
+    name: "dsh-account",
+
+    formatErrorBody(status: number, headers: Headers, payloadText: string): string {
+      if (status === 401) {
+        return "DeepSeek Harness account authentication failed (401 / ACCOUNT_TOKEN_INVALID). Please sign in to DeepSeek Harness Desktop and re-import.";
+      }
+      return baseAdapter.formatErrorBody?.(status, headers, payloadText) ?? payloadText;
+    },
+
+    async buildRequest(parsed: OcxParsedRequest, incoming: IncomingMeta) {
+      const token = provider.apiKey?.trim();
+      if (!token) {
+        throw new Error("DeepSeek Harness account token missing — import your account in Providers > DeepSeek Account (DSH)");
+      }
+
+      // Fail-closed if custom provider configuration attempts to set any reserved header
+      if (provider.headers) {
+        for (const key of Object.keys(provider.headers)) {
+          if (DSH_ACCOUNT_RESERVED_HEADERS.has(key.toLowerCase())) {
+            throw new Error(`Reserved header "${key}" cannot be overridden in dsh-account provider configuration`);
+          }
+        }
+      }
+
+      const req = await baseAdapter.buildRequest(parsed, incoming);
+      const url = resolveDshAccountMessagesUrl(provider.baseUrl);
+
+      const headers: Record<string, string> = { ...req.headers };
+
+      // Apply custom provider headers strictly before authoritative authentication headers
+      if (provider.headers) {
+        for (const [key, value] of Object.entries(provider.headers)) {
+          if (!DSH_ACCOUNT_RESERVED_HEADERS.has(key.toLowerCase()) && typeof value === "string") {
+            headers[key] = value;
+          }
+        }
+      }
+
+      // Authoritative cleanup: strip any API key or Claude headers
+      for (const key of Object.keys(headers)) {
+        const lower = key.toLowerCase();
+        if (
+          lower === "authorization"
+          || lower === "x-api-key"
+          || lower === "x-dsh-auth-token"
+          || lower === "anthropic-version"
+          || lower === "anthropic-beta"
+          || lower === "x-claude-code-session-id"
+          || lower === "x-client-request-id"
+        ) {
+          delete headers[key];
+        }
+      }
+
+      // Set authoritative DeepSeek Harness Account headers strictly at the end
+      headers["x-dsh-auth-token"] = token;
+      headers["anthropic-version"] = "2023-06-01";
+      if (!headers["Content-Type"]) headers["Content-Type"] = "application/json";
+      if (!headers["Accept"]) headers["Accept"] = parsed.stream ? "text/event-stream" : "application/json";
+
+      return {
+        ...req,
+        url,
+        headers,
+        redirect: "manual",
+      };
+    },
+  };
+}

package/src/adapters/google-antigravity-wire.ts

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import type { OcxContentPart, OcxParsedRequest } from "../types";
-import { antigravityUserAgent } from "./client-fingerprint";
+import { antigravityCliUserAgent, antigravityUserAgent } from "./client-fingerprint";
 
 /**
  * Antigravity request User-Agent. Mirrors the real Antigravity IDE UA
@@ -11,6 +11,27 @@ import { antigravityUserAgent } from "./client-fingerprint";
  */
 export const ANTIGRAVITY_REQUEST_UA = antigravityUserAgent();
 
+/**
+ * Antigravity CLI User-Agent. CCA serves Gemini 4 Argon only to the CLI client family, and it
+ * 404s other agent models (`gemini-3.7-flash-tiered`, `gemini-3.1-pro-low`) under it, so the
+ * choice is per wire model: see `antigravityUserAgentForWireModel`.
+ */
+export const ANTIGRAVITY_CLI_REQUEST_UA = antigravityCliUserAgent();
+
+/**
+ * Model discovery (`:fetchAvailableModels`) uses the CLI UA so Argon's wire ids are listed;
+ * under the IDE UA they are absent.
+ */
+export const ANTIGRAVITY_DISCOVERY_UA = ANTIGRAVITY_CLI_REQUEST_UA;
+
+/** Wire ids CCA serves only to the CLI client family (verified 2026-10-14). */
+const ANTIGRAVITY_CLI_ONLY_WIRE_MODEL = /^gemini-4-argon(?:-(?:low|medium|high))?$/;
+
+/** The User-Agent an Antigravity inference request for `wireModelId` must carry. */
+export function antigravityUserAgentForWireModel(wireModelId: string): string {
+  return ANTIGRAVITY_CLI_ONLY_WIRE_MODEL.test(wireModelId) ? ANTIGRAVITY_CLI_REQUEST_UA : ANTIGRAVITY_REQUEST_UA;
+}
+
 /**
  * Whether a stored `OcxToolCall.thoughtSignature` is a REAL upstream Gemini signature versus a
  * foreign id that must not be forwarded to Gemini/Antigravity.

package/src/adapters/google.ts

@@ -1,6 +1,8 @@
+import { openCodeZenGeminiEndpoint } from "../types/opencode-zen";
 import type { AdapterFetchContext, AdapterRequest, ProviderAdapter } from "./base";
 import { debugDroppedFrame, debugProviderDiagnosticLazy } from "../lib/debug";
 import { createToolCallIdAllocator } from "./tool-call-id";
+import { openCodeGoGeminiEndpoint } from "../types/opencode-go";
 import { createImageBudget, materializeInlineImage, MAX_ENCODED_BYTES_PER_IMAGE, artifactHttpUrl } from "../images/artifacts";
 import type {
   AdapterEvent,
@@ -17,11 +19,11 @@ import type {
 import { isAllowedToolChoice, namespacedToolName, resolveToolChoiceWireName, toolChoiceToolPredicate } from "../types";
 import type { OcxTool } from "../types";
 import { contentPartsToText, parseDataUrl } from "./image";
-import { getVertexAccessToken } from "../lib/gcp-adc";
+import { GCP_CREDENTIAL_MARKER_PREFIX, gcpCredentialMarkerAccount, getVertexAccessToken } from "../lib/gcp-adc";
 import { fetchAntigravityWithRetry, fetchVertexWithRetry } from "./google-http";
 import { safeAntigravityHttpErrorMessage, safeVertexHttpErrorMessage } from "./google-errors";
 import { isVertexTruncatedTurn, vertexTruncationErrorEvent } from "./google-truncation";
-import { ANTIGRAVITY_REQUEST_UA, antigravitySessionAnchor, antigravitySessionId, isLikelyRealThoughtSignature, sanitizeAntigravityClaudeSignatures } from "./google-antigravity-wire";
+import { antigravitySessionAnchor, antigravityUserAgentForWireModel, antigravitySessionId, isLikelyRealThoughtSignature, sanitizeAntigravityClaudeSignatures } from "./google-antigravity-wire";
 import { summarizeGoogleWireShape } from "./google-wire-shape";
 import { compileGoogleWireBody } from "./google-wire-compiler";
 import type { GoogleToolSchemaLossReport, GoogleToolSchemaProfile } from "./google-tool-schema";
@@ -174,7 +176,15 @@ function resolveDirectGeminiWireModelId(modelId: string, applyRenames: boolean):
 
 /** Vertex API key: provider.apiKey if it looks real (not a sentinel), else GOOGLE_CLOUD_API_KEY env. */
 function resolveVertexApiKey(optKey?: string): string | undefined {
-  const realKey = optKey && !optKey.startsWith("<") && optKey !== "N/A" ? optKey : undefined;
+  // A `gcp-sa:` marker is the keychain-backed credential reference (see gcp-adc): it is not
+  // API-key material, so it must not be sent as x-goog-api-key — the ADC branch below handles it.
+  // AND the marker means the operator named one credential explicitly: the GOOGLE_CLOUD_API_KEY
+  // env fallback must NOT fire (it would silently route this provider's inference through the
+  // ambient env key instead of the configured service account).
+  if (optKey && optKey.startsWith(GCP_CREDENTIAL_MARKER_PREFIX)) return undefined;
+  const realKey = optKey && !optKey.startsWith("<") && optKey !== "N/A"
+    ? optKey
+    : undefined;
   return realKey || process.env.GOOGLE_CLOUD_API_KEY;
 }
 
@@ -864,6 +874,7 @@ function invalidGoogleShapeEvent(
   };
 }
 
+/** Build Gemini transport and response parsing for AI Studio, Vertex, Cloud Code Assist or Go. */
 export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapter {
   const toolSchemaPolicy = provider.googleToolSchemaPolicy ?? "compatible";
   const toolSchemaProfile = {
@@ -945,6 +956,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         }
       : {}),
 
+    /** Compile an admitted request into the selected Gemini endpoint, body and authentication. */
     async buildRequest(parsed: OcxParsedRequest) {
       // Structured-output admission runs FIRST, before messagesToGeminiFormat writes
       // lastInjectedCallIds/lastReasoningReplayScope: a refused request must not leave
@@ -983,7 +995,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
             mapReasoningEffort(provider, parsed.modelId, parsed.options.reasoning),
             provider.baseUrl,
           ).wireModelId
-        : provider.googleMode === "vertex"
+        : provider.googleMode === "vertex" || openCodeZenGeminiEndpoint(provider, parsed.modelId) !== undefined
           ? parsed.modelId
           : resolveDirectGeminiWireModelId(parsed.modelId, provider.directGeminiWireRenames !== false);
       returnsThoughtSummaries = provider.googleMode === "cloud-code-assist"
@@ -1155,7 +1167,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           requestId: `agent-${crypto.randomUUID()}`,
           request,
         };
-        headers["User-Agent"] = ANTIGRAVITY_REQUEST_UA;
+        headers["User-Agent"] = antigravityUserAgentForWireModel(wireModelId);
         headers["Authorization"] = `Bearer ${token}`;
         return { url, method: "POST", headers, body: JSON.stringify(envelope) };
       }
@@ -1197,16 +1209,31 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         if (locationError) throw new Error(locationError);
         const host = location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`;
         const url = `https://${host}/v1/projects/${project}/locations/${location}/publishers/google/models/${parsed.modelId}:${method}${streamParam}`;
-        const token = await getVertexAccessToken();
+        // The marker account travels per-request as an argument (never process-global state): a
+        // module-level "active marker" written at routing time would race across concurrent
+        // requests for different providers and could resolve one call with another's credential.
+        const markerAccount = gcpCredentialMarkerAccount(provider.apiKey);
+        const token = await getVertexAccessToken({ markerAccount });
         headers["Authorization"] = `Bearer ${token}`;
         return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
       }
 
-      // ai-studio (default): Generative Language API + x-goog-api-key.
-      const url = `${provider.baseUrl}/v1beta/models/${routedModelId}:${method}${streamParam}`;
+      // Go and Zen use separate guarded Gemini endpoints; AI Studio retains /v1beta.
+      const goEndpoint = openCodeGoGeminiEndpoint(provider, routedModelId);
+      const zenEndpoint = openCodeZenGeminiEndpoint(provider, routedModelId);
+      const endpoint = goEndpoint ?? zenEndpoint ?? `${provider.baseUrl}/v1beta/models/${routedModelId}`;
+      const url = `${endpoint}:${method}${streamParam}`;
       const apiKey = provider.apiKey?.trim();
-      if (!apiKey) throw new Error("google (AI Studio) requires a non-empty API key");
-      headers["x-goog-api-key"] = apiKey;
+      if (!apiKey) throw new Error(`${goEndpoint ? "OpenCode Go" : zenEndpoint ? "OpenCode Zen" : "google (AI Studio)"} requires a non-empty API key`);
+      if (goEndpoint) {
+        // Console inference documents Bearer auth. Send only the selected Go key.
+        for (const name of Object.keys(headers)) {
+          if (["authorization", "x-goog-api-key", "x-api-key"].includes(name.toLowerCase())) delete headers[name];
+        }
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      } else {
+        headers["x-goog-api-key"] = apiKey;
+      }
 
       const compiled = compileGoogleWireBody(body, toolSchemaProfile, toolSchemaPolicy);
       reportToolSchemaLoss(compiled.toolSchemaLossReport);

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

@@ -7,6 +7,7 @@ import { EMPTY_TOOL_OUTPUT_ANNOTATION, isWhitespaceOnlyTextPartArray } from "../
 import { identifyRoutedModel } from "../identity";
 import { buildNonOpenAIToolCatalogNudgeForTools, shouldInjectNonOpenAIToolCatalogNudge } from "../tool-catalog-nudge";
 import { peekReasoningForCall } from "../../responses/reasoning-replay-cache";
+import { chatReasoningReplayPolicy } from "./reasoning-replay";
 import type { ClaudeThinkingProjection } from "../../lib/claude-request-projection";
 import { inlineDocumentDataUrl } from "../../responses/inline-document";
 import type { OcxAssistantMessage, OcxContentPart, OcxParsedRequest, OcxProviderConfig, OcxTextContent, OcxThinkingContent, OcxToolCall } from "../../types";
@@ -75,7 +76,7 @@ export function openAIChatSerializesThinking(
   modelId: string,
 ): ClaudeThinkingProjection {
   return {
-    text: modelInList(provider.preserveReasoningContentModels, modelId),
+    text: chatReasoningReplayPolicy(provider, modelId).preserve,
     // The wire has no `signature` field — base64 replay tokens are Anthropic-wire-only.
     signature: false,
     // A `redacted_thinking` block is opaque provider data with no Chat representation: the
@@ -267,7 +268,7 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
           // recorded under every call id — join unique texts only.
           if (cached.length > 0) {
             reasoningContent = [...new Set(cached)].join("\n");
-          } else if (modelInList(provider.requiresReasoningPlaceholderModels ?? provider.preserveReasoningContentModels, parsed.modelId)) {
+          } else if (chatReasoningReplayPolicy(provider, parsed.modelId).placeholder) {
             // 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 thinking/tool rounds carry no recorded
@@ -354,7 +355,7 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
           const orphanReasoning =
             cachedReasoning
             || (wireSerializesThinking
-              && modelInList(provider.requiresReasoningPlaceholderModels ?? provider.preserveReasoningContentModels, parsed.modelId)
+              && chatReasoningReplayPolicy(provider, parsed.modelId).placeholder
               ? " "
               : undefined);
           const orphanReasoningFields: Record<string, unknown> = !orphanReasoning

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

@@ -14,6 +14,8 @@ import { modelRecordValue } from "../../reasoning-effort";
 import { modelInList, type OcxProviderConfig } from "../../types";
 import { chatParallelToolCallsWireValue } from "./parallel-tool-calls";
 import { applyExplicitChatReasoningWirePolicy } from "./reasoning-wire";
+import { replayNativeChatReasoning } from "./reasoning-replay";
+import type { OcxReasoningReplayScopeRef } from "../../types";
 
 const CHAT_PASSTHROUGH_FIELDS = [
   "audio",
@@ -55,17 +57,19 @@ export function buildOpenAIChatPassthroughRequest(
   fastPolicy: ResolvedFastPolicy = fastPolicyForModel(provider, modelId, undefined, "chat"),
   fastMode?: boolean,
   providerName?: string,
+  replayScope?: OcxReasoningReplayScopeRef,
 ): AdapterRequest {
   const { url, headers, hasCredential } = openAIChatTransport(provider);
 
   const body: Record<string, unknown> = {
     model: provider.modelSuffixBracketStrip ? stripBracketedModelSuffix(modelId) : modelId,
-    // The caller's messages are forwarded as they arrived, with one exception: an operator who
+    // The caller's messages retain their wire shape. An operator who
     // recorded that this destination rejects the `developer` role gets that role converted in
     // place. Verbatim was not neutral there — it sent the role anyway and the turn failed
     // upstream with a 400 before the model saw it. An unrecorded destination is still verbatim,
     // and the conversion changes the role of those messages and nothing else, so the position
-    // of every message and every other field survive unchanged.
+    // of every message and every other field survive unchanged. Missing thinking history is
+    // repaired below using the same preserve policy as the translated Chat builder.
     messages: applyExplicitChatDeveloperRole(
       frameAgentRouterMessages(provider.baseUrl, rawBody.messages),
       provider,
@@ -75,6 +79,8 @@ export function buildOpenAIChatPassthroughRequest(
   for (const field of CHAT_PASSTHROUGH_FIELDS) {
     if (rawBody[field] !== undefined) body[field] = rawBody[field];
   }
+  body.messages = replayNativeChatReasoning(body.messages, provider, modelId, replayScope,
+    Array.isArray(rawBody.tools) && rawBody.tools.length > 0);
   if (protectGlmSummaryBudget(body, provider.baseUrl, body.reasoning_effort)) body.reasoning_effort = "low";
   const rawEfforts = modelRecordValue(provider.modelReasoningEfforts, modelId) ?? provider.reasoningEfforts;
   const reasoningDisabled = modelInList(provider.noReasoningModels, modelId) || rawEfforts?.length === 0;

package/src/adapters/openai-chat/reasoning-replay.ts

@@ -0,0 +1,52 @@
+import { modelInList, type OcxProviderConfig, type OcxReasoningReplayScopeRef } from "../../types";
+import { peekReasoningForCall } from "../../responses/reasoning-replay-cache";
+
+type Rec = Record<string, unknown>;
+export const isChatRecord = (value: unknown): value is Rec =>
+  value !== null && typeof value === "object" && !Array.isArray(value);
+
+const isDeepSeekThinkingModel = (modelId: string): boolean =>
+  /(?:^|\/)deepseek-(?:v\d+(?:\.\d+)*-(?:flash|pro)|flash|pro)(?:$|[-_:])/i.test(modelId);
+
+/** DeepSeek thinking tool replay is a model contract, independent of the gateway's name. */
+export function chatReasoningReplayPolicy(provider: OcxProviderConfig, modelId: string): {
+  preserve: boolean; placeholder: boolean;
+} {
+  // Match whole model-family tokens, including dotted versions, namespace and deployment suffixes.
+  // Legacy chat/reasoner and distilled R1 models do not share the thinking tool-call contract.
+  const preserve = provider.preserveReasoningContentModels === undefined
+    ? isDeepSeekThinkingModel(modelId)
+    : modelInList(provider.preserveReasoningContentModels, modelId);
+  return {
+    preserve,
+    placeholder: preserve && (provider.requiresReasoningPlaceholderModels === undefined
+      ? true
+      : modelInList(provider.requiresReasoningPlaceholderModels, modelId)),
+  };
+}
+
+/** Repair missing native history without mutating caller bodies used by retries/combo siblings. */
+export function replayNativeChatReasoning(
+  messages: unknown,
+  provider: OcxProviderConfig,
+  modelId: string,
+  scope?: OcxReasoningReplayScopeRef,
+  hasTools = false,
+): unknown {
+  const policy = chatReasoningReplayPolicy(provider, modelId);
+  if (!policy.preserve || !Array.isArray(messages)
+      || modelInList(provider.reasoningDetailsModels, modelId)) return messages;
+  return messages.map(message => {
+    if (!isChatRecord(message) || message.role !== "assistant"
+        || (typeof message.reasoning_content === "string" && message.reasoning_content.length > 0)) return message;
+    const calls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+    // DeepSeek's tools contract covers all prior assistant turns, even plain answers.
+    // Those turns have no call id for original replay; only the configured fallback applies.
+    if (calls.length === 0 && !(hasTools && isDeepSeekThinkingModel(modelId))) return message;
+    const cached = calls.filter(isChatRecord)
+      .map(tool => typeof tool.id === "string" ? peekReasoningForCall(tool.id, scope) : undefined)
+      .filter((text): text is string => typeof text === "string" && text.length > 0);
+    const reasoning = cached.length > 0 ? [...new Set(cached)].join("\n") : policy.placeholder ? " " : undefined;
+    return reasoning === undefined ? message : { ...message, reasoning_content: reasoning };
+  });
+}

package/src/adapters/openai-chat/response-events.ts

@@ -1,6 +1,7 @@
 import { diagnoseInvalidToolCalls, isRecord, type InvalidToolCallDiagnostic } from "./tool-call-validation";
 import { TranslatorBudgetExceededError, type TranslatorBudget } from "../../lib/translator-budget";
-import type { AdapterEvent, OcxUsage } from "../../types";
+import type { AdapterEvent, OcxProviderConfig, OcxUsage } from "../../types";
+import { createInlineThinkContentSplitter } from "../inline-think-tags";
 
 export function stopReasonFor(finishReason: unknown): "max_tokens" | "content_filter" | undefined {
   return finishReason === "length"
@@ -18,6 +19,63 @@ export function reasoningTextFrom(record: Record<string, unknown>): string | und
       : undefined;
 }
 
+type ChatContentEvent = Extract<AdapterEvent, { type: "text_delta" | "reasoning_raw_delta" | "error" }>;
+
+/** Mistral can mix typed blocks and strings in one response. Other destinations keep their parser. */
+export function chatContentEvents(content: unknown, baseUrl: string, usage?: OcxUsage, buffered = false): ChatContentEvent[] {
+  if (typeof content === "string") return content.length > 0 || buffered ? [{ type: "text_delta", text: content }] : [];
+  if (!Array.isArray(content)) return [];
+  let host: string;
+  try { host = new URL(baseUrl).hostname; } catch { return []; }
+  if (host !== "api.mistral.ai") return [];
+  const invalid = (): ChatContentEvent[] => [{
+    type: "error", status: 502, errorType: "upstream_error",
+    message: "unsupported Mistral content block", ...(usage ? { usage } : {}),
+  }];
+  const events: ChatContentEvent[] = [];
+  for (const block of content) {
+    if (!isRecord(block)) return invalid();
+    if (block.type === "text" && typeof block.text === "string") {
+      if (block.text.length > 0 || buffered) events.push({ type: "text_delta", text: block.text });
+    } else if (block.type === "thinking" && Array.isArray(block.thinking)) {
+      for (const inner of block.thinking) {
+        if (!isRecord(inner) || inner.type !== "text" || typeof inner.text !== "string") return invalid();
+        if (inner.text.length > 0) events.push({ type: "reasoning_raw_delta", text: inner.text });
+      }
+    } else return invalid();
+  }
+  return events;
+}
+
+/** Keep adjacent text together; typed reasoning flushes and resets inline-tag parsing. */
+export function createChatContentSplitter(provider: OcxProviderConfig, modelId: string | undefined, budget: TranslatorBudget) {
+  let splitter = createInlineThinkContentSplitter(provider.inlineThinkTagModels, modelId, budget);
+  return {
+    feed(event: ChatContentEvent): AdapterEvent[] {
+      if (event.type === "error") return [event];
+      if (event.type === "text_delta") return splitter.feed(event.text);
+      const pending = splitter.flush();
+      splitter.dispose();
+      splitter = createInlineThinkContentSplitter(provider.inlineThinkTagModels, modelId, budget);
+      return [...pending, event];
+    },
+    flush: () => splitter.flush(),
+    dispose: () => splitter.dispose(),
+  };
+}
+
+/** Split a buffered answer with the same typed-reasoning boundaries as a stream. */
+export function splitChatContentEvents(content: unknown, provider: OcxProviderConfig, modelId: string | undefined, budget: TranslatorBudget, usage?: OcxUsage): AdapterEvent[] {
+  const events = chatContentEvents(content, provider.baseUrl, usage, true);
+  if (events.some(event => event.type === "error")) return events;
+  const splitter = createChatContentSplitter(provider, modelId, budget);
+  try {
+    return [...events.flatMap(event => splitter.feed(event)), ...splitter.flush()];
+  } finally {
+    splitter.dispose();
+  }
+}
+
 export interface ReasoningDetailSegment {
   key: string;
   text: string;

package/src/adapters/openai-chat.ts

@@ -5,7 +5,6 @@ import { applyExplicitChatReasoningWirePolicy } from "./openai-chat/reasoning-wi
 import type { AdapterRequest, IncomingMeta, ProviderAdapter } from "./base";
 import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig, OcxUsage } from "../types";
 import { modelInList } from "../types";
-import { createInlineThinkContentSplitter, splitInlineThinkContent } from "./inline-think-tags";
 import { mapReasoningEffort } from "../reasoning-effort";
 import { debugProviderDiagnostic } from "../lib/debug";
 import { sseFieldValue } from "../lib/sse-decoder";
@@ -28,6 +27,7 @@ import {
   type InvalidToolCallDiagnostic,
 } from "./openai-chat/tool-call-validation";
 import {
+  chatContentEvents, createChatContentSplitter, splitChatContentEvents,
   createReasoningDetailSnapshotTracker,
   invalidChoicesEvent,
   invalidToolCallsEvent,
@@ -368,7 +368,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       const reasoningDetailsOptIn = modelInList(provider.reasoningDetailsModels, lastRequestedModelId ?? "");
       // A gateway with no server-side reasoning parser leaves thinking inline in `content` as
       // <think> blocks, which would otherwise render as the answer. Passthrough unless opted in.
-      const inlineThink = createInlineThinkContentSplitter(provider.inlineThinkTagModels, lastRequestedModelId, budget);
+      const inlineThink = createChatContentSplitter(provider, lastRequestedModelId, budget);
       const emitContent = function* (events: AdapterEvent[]): Generator<AdapterEvent> {
         for (const event of events) {
           // Any other event keeps its place behind held text instead of overtaking it.
@@ -444,8 +444,9 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
             const reasoningText = reasoningTextFrom(delta);
             if (reasoningText !== undefined) yield* toolCallContent.hold({ type: "reasoning_raw_delta", text: reasoningText });
           }
-          if (typeof delta.content === "string" && delta.content.length > 0) {
-            yield* emitContent(inlineThink.feed(delta.content));
+          for (const event of chatContentEvents(delta.content, provider.baseUrl, pendingUsage)) {
+            if (event.type === "error") return yield* terminateWithError(event);
+            yield* emitContent(inlineThink.feed(event));
           }
 
           const rawToolCalls = delta.tool_calls;
@@ -767,7 +768,9 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         }
         if (reasoningText !== undefined) events.push({ type: "reasoning_raw_delta", text: reasoningText });
         const contentStart = events.length;
-        if (typeof msg.content === "string") events.push(...splitInlineThinkContent(provider.inlineThinkTagModels, lastRequestedModelId, budget, msg.content));
+        const contentEvents = splitChatContentEvents(msg.content, provider, lastRequestedModelId, budget, usage);
+        if (contentEvents.some(event => event.type === "error")) return contentEvents;
+        events.push(...contentEvents);
         const contentEnd = events.length;
         const answerText = events.slice(contentStart).map(event => (event.type === "text_delta" ? event.text : "")).join("");
         // Each call holds the delta event it emitted, so the batch repair sets its arguments later.