@bitkyc08/opencodex 2.88.0 → 2.90.0

package/src/adapters/google.ts

@@ -36,7 +36,7 @@ import {
   observeAntigravityReplay,
 } from "./google-antigravity-replay";
 import { canonicalAntigravityUsageModel, resolveAntigravityEffortWireModel } from "../providers/antigravity-models";
-import { googleVertexLocationConfigError } from "../providers/google-vertex-location";
+import { selectVertexEndpoint, vertexInferenceUrl, vertexReplayModelKey } from "./google-vertex-endpoint";
 import { forgetThoughtSignatureForReplay, lookupReplayThoughtSignature } from "../responses/thought-signature-replay";
 import {
   isTranslatorBudgetExceededError,
@@ -333,13 +333,20 @@ function geminiToolResultParts(
   msg: OcxToolResultMessage,
   wireName: string,
   wireCallId: string,
+  nestToolResultImages: boolean,
 ): unknown[] {
   const functionResponse: Record<string, unknown> = {
     name: wireName,
     response: { result: geminiToolResultText(msg.content) },
     id: wireCallId,
   };
-  return [{ functionResponse }, ...toolResultImageParts(msg.content)];
+  const images = toolResultImageParts(msg.content);
+  // Vertex Argon rejects image siblings beside a functionResponse as an unsupported model tail.
+  if (nestToolResultImages && images.length > 0) {
+    functionResponse.parts = images;
+    return [{ functionResponse }];
+  }
+  return [{ functionResponse }, ...images];
 }
 
 function geminiMissingToolResultPart(wireName: string, wireCallId: string): unknown {
@@ -370,6 +377,8 @@ function messagesToGeminiFormat(
   identityModelId: string,
   stripRejectedClaudeSdkParagraph = false,
   isCloudCodeAssist = false,
+  nestToolResultImages = false,
+  toolResponseImagesLast = false,
 ): { systemInstruction?: unknown; contents: unknown[]; replayedCallIds: string[] } {
   // Neutralize Codex's GPT-5 identity line (Gemini/Antigravity share this path) so a routed model
   // never misreports as GPT-5/OpenAI, and never leaks the proxy identity upstream.
@@ -549,15 +558,25 @@ function messagesToGeminiFormat(
           }
 
           const responseParts: unknown[] = [];
+          const trailingImages: unknown[] = [];
           for (const call of toolCalls) {
             const result = resultsById.get(call.wireCallId);
-            if (result) responseParts.push(...geminiToolResultParts(result, call.wireName, call.wireCallId));
-            else responseParts.push(geminiMissingToolResultPart(call.wireName, call.wireCallId));
-          }
-          for (const orphan of orphanResults) {
-            responseParts.push(...geminiOrphanToolResultParts(orphan));
+            if (result) {
+              const [response, ...images] = geminiToolResultParts(result, call.wireName, call.wireCallId, nestToolResultImages);
+              responseParts.push(response);
+              (toolResponseImagesLast ? trailingImages : responseParts).push(...images);
+            } else responseParts.push(geminiMissingToolResultPart(call.wireName, call.wireCallId));
           }
+          // CCA Claude misses later responses when image siblings interrupt the response batch.
+          responseParts.push(...trailingImages);
+          const orphanParts = orphanResults.flatMap(geminiOrphanToolResultParts);
           contents.push({ role: "user", parts: responseParts });
+          // Orphan images cannot share Argon's response batch or claim another call's ownership.
+          if (nestToolResultImages && orphanParts.some(part => typeof part === "object" && part !== null && "inline_data" in part)) {
+            contents.push({ role: "user", parts: orphanParts });
+          } else {
+            responseParts.push(...orphanParts);
+          }
           i = j - 1;
         }
         break;
@@ -1014,7 +1033,14 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         : provider.googleMode === "vertex" || openCodeZenGeminiEndpoint(provider, parsed.modelId) !== undefined
           ? parsed.modelId
           : resolveDirectGeminiWireModelId(parsed.modelId, provider.directGeminiWireRenames !== false);
-      returnsThoughtSummaries = provider.googleMode === "cloud-code-assist"
+      const configuredEfforts = configuredReasoningEfforts(provider, parsed.modelId);
+      const thinkingEligible = provider.googleMode !== "cloud-code-assist"
+        && !isImageCapableModel(parsed.modelId)
+        && (configuredEfforts !== undefined
+          ? configuredEfforts.length > 0
+          : (provider.googleMode !== "vertex"
+            && (parsed.modelId === "gemini-3.5-flash" || parsed.modelId === "gemini-3.6-flash")));
+      returnsThoughtSummaries = (provider.googleMode === "cloud-code-assist" || (thinkingEligible && provider.showThinkingSummary === true))
         && /^gemini-/.test(routedModelId) && !isImageCapableModel(parsed.modelId);
       // AI Studio's `-tiered` spelling is wire-only; CCA aliases may migrate to another generation.
       const identityModelId = provider.googleMode === "cloud-code-assist" ? routedModelId : parsed.modelId;
@@ -1026,6 +1052,8 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         identityModelId,
         stripRejectedClaudeSdkParagraph,
         isCloudCodeAssist,
+        provider.googleMode === "vertex" && parsed.modelId === "gemini-4-argon",
+        isCloudCodeAssist && /^claude-/i.test(routedModelId),
       );
       lastInjectedCallIds = [...replayedCallIds];
       lastReasoningReplayScope = parsed._reasoningReplayScope;
@@ -1052,15 +1080,19 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       // current behavior; Vertex participates only through an explicitly configured ladder (the
       // seed google-vertex entry ships none). Image models are excluded — thinkingConfig would
       // suppress the responseModalities fallback below. CCA maps effort on its envelope path.
-      const thinkingEligible = provider.googleMode !== "cloud-code-assist"
-        && !isImageCapableModel(parsed.modelId)
-        && (configuredReasoningEfforts(provider, parsed.modelId) !== undefined
-          || (provider.googleMode !== "vertex"
-            && (parsed.modelId === "gemini-3.5-flash" || parsed.modelId === "gemini-3.6-flash")));
       const thinkingLevel = thinkingEligible
         ? mapReasoningEffort(provider, parsed.modelId, parsed.options.reasoning)
         : undefined;
-      if (thinkingLevel) generationConfig.thinkingConfig = { thinkingLevel };
+      const includeThoughts = thinkingEligible
+        && provider.showThinkingSummary === true
+        && parsed.options.hideThinkingSummary !== true
+        && /^gemini-/.test(routedModelId);
+      if (thinkingLevel || includeThoughts) {
+        generationConfig.thinkingConfig = {
+          ...(thinkingLevel ? { thinkingLevel } : {}),
+          ...(includeThoughts ? { includeThoughts: true } : {}),
+        };
+      }
       if (!generationConfig.thinkingConfig && isImageCapableModel(parsed.modelId)) {
         generationConfig.responseModalities = ["TEXT", "IMAGE"];
       }
@@ -1192,9 +1224,10 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         const compiled = compileGoogleWireBody(body, toolSchemaProfile, toolSchemaPolicy);
         reportToolSchemaLoss(compiled.toolSchemaLossReport);
         restoreGoogleToolName = compiled.restoreToolName;
-        const vertexProject = provider.project || process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT || "api-key";
-        const vertexLocation = provider.location || process.env.GOOGLE_CLOUD_LOCATION || "global";
-        vertexReplayModel = `vertex:${vertexProject}:${vertexLocation}:${parsed.modelId}`;
+        const apiKey = resolveVertexApiKey(provider.apiKey);
+        const vertexEndpoint = selectVertexEndpoint(provider, Boolean(apiKey));
+        const url = vertexInferenceUrl(vertexEndpoint, parsed.modelId, method, streamParam);
+        vertexReplayModel = vertexReplayModelKey(vertexEndpoint, parsed.modelId);
         vertexReplaySession = vertexReplaySessionId(parsed);
         // Compile names before replay so the cache matches the exact provider-visible
         // functionCall identity. This is the same bounded TTL/LRU store used by CCA, with the
@@ -1210,27 +1243,13 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
             (compiled.body as { contents: unknown[] }).contents,
           );
         }
-        // Vertex AI: project/location endpoint with GCP ADC, or x-goog-api-key fast path.
-        const apiKey = resolveVertexApiKey(provider.apiKey);
-        if (apiKey) {
-          const url = `https://aiplatform.googleapis.com/v1/publishers/google/models/${parsed.modelId}:${method}${streamParam}`;
-          headers["x-goog-api-key"] = apiKey;
-          return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
+        // Endpoint, location and model path were validated above, before any credential is attached.
+        if (apiKey) headers["x-goog-api-key"] = apiKey;
+        else {
+          // Resolve each marker per request; never share a process-global active account.
+          const markerAccount = gcpCredentialMarkerAccount(provider.apiKey);
+          headers["Authorization"] = `Bearer ${await getVertexAccessToken({ markerAccount })}`;
         }
-        const project = provider.project || process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT;
-        if (!project) throw new Error("Vertex AI requires a project id (provider.project or GOOGLE_CLOUD_PROJECT/GCLOUD_PROJECT).");
-        const location = provider.location || process.env.GOOGLE_CLOUD_LOCATION;
-        if (!location) throw new Error("Vertex AI requires a location (provider.location or GOOGLE_CLOUD_LOCATION).");
-        const locationError = googleVertexLocationConfigError(location);
-        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}`;
-        // 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) };
       }
 
@@ -1254,6 +1273,12 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       const compiled = compileGoogleWireBody(body, toolSchemaProfile, toolSchemaPolicy);
       reportToolSchemaLoss(compiled.toolSchemaLossReport);
       restoreGoogleToolName = compiled.restoreToolName;
+      // A functionCall issued by another model (a combo hop, #7298) has no Gemini signature, and
+      // Gemini 3 refuses the turn without one. The same Gemini-only sentinel CCA and Vertex
+      // apply; a real signature carried by history always wins.
+      if (Array.isArray((compiled.body as { contents?: unknown[] }).contents)) {
+        applyAntigravityThoughtSignatureFallback(routedModelId, (compiled.body as { contents: unknown[] }).contents);
+      }
       return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
     },
 

package/src/adapters/image.ts

@@ -18,9 +18,11 @@ export function parseDataUrl(url: string): { mediaType: string; base64: string }
  */
 export function contentPartsToText(content: string | OcxContentPart[]): string {
   if (typeof content === "string") return content;
-  // A document carries its own marker, so this wire states the attachment instead of
-  // mislabelling it as a video.
+  // Documents and audio carry their own markers, so this wire states the attachment instead
+  // of mislabelling it as a video.
   const text = content.map(p =>
-    p.type === "text" || p.type === "document" ? p.text : p.type === "image" ? "[image]" : "[video]").join("");
+    p.type === "text" || p.type === "document" || p.type === "audio"
+      ? p.text
+      : p.type === "image" ? "[image]" : "[video]").join("");
   return text || "[image]";
 }

package/src/adapters/input-media-guard.ts

@@ -10,7 +10,8 @@ import type { OcxParsedRequest } from "../types";
  * out because it uses the original body rather than the lossy normalized content.
  *
  * Two of the three checks are wire-scoped, and that is the point. A constraint the normalized
- * request CAN carry — a caller restriction on a tool, an attached document's bytes — still has
+ * request CAN carry — a caller restriction on a tool, an attached document's bytes, or inline
+ * audio in the translated Chat content model — still has
  * to reach a wire that can express it. Leaving that to each adapter means an adapter that never
  * learned about the carrier rebuilds without it and answers normally, so the allowlist in
  * `declaration-carrier.ts` is default-deny and this is the one place every registered adapter
@@ -18,7 +19,9 @@ import type { OcxParsedRequest } from "../types";
  */
 export function withInputMediaGuard<T extends ProviderAdapter>(adapter: T, wire: AdapterWire): T {
   const refusal = (parsed: OcxParsedRequest): string | undefined => {
-    const kind = untranslatedResponsesInputMedia(parsed._rawBody);
+    // Chat Completions has a native input_audio user-content part. The adapter promotes
+    // tool-result audio into a follow-up user message, so these blocks no longer lose bytes.
+    const kind = untranslatedResponsesInputMedia(parsed._rawBody, { allowAudio: wire === "openai-chat" });
     return kind ? untranslatedInputMediaMessage(kind) : unrepresentableDeclaration(parsed, wire);
   };
   const build = adapter.buildRequest.bind(adapter);

package/src/adapters/kiro-refusal.ts

@@ -1,8 +1,13 @@
 /** Account-scoped Kiro refusals. Unknown data never convicts an account. */
 import { BOUNDED_BODY_MAX_BYTES } from "../lib/bounded-body";
-export type KiroRefusalKind = "rate" | "monthly_quota" | "suspended" | "other";
+export type KiroRefusalKind = "rate" | "monthly_quota" | "suspended" | "profile" | "other";
 export interface KiroRefusal { kind: KiroRefusalKind; resetAt?: number }
 
+/** The vendor's own name for the body validator that rejects a request for this identity. */
+const VALIDATION_EXCEPTION = "ValidationException";
+/** Kiro's wording for that rejection; the code alone is also what a genuinely bad payload gets. */
+const IMPROPER_REQUEST_WORD = /improperly formed request/i;
+
 const SUSPENSION_WORDS = [
   "temporarily suspended", "temporarily is suspended",
   "locked your account", "locked it as a",
@@ -22,9 +27,44 @@ export function classifyKiroRefusal(status: number, bodyText: string): KiroRefus
   } catch { /* Unrecognised bodies cannot establish an account verdict. */ }
   if ((status === 400 || status === 429) && reason === "MONTHLY_REQUEST_COUNT")
     return { kind: "monthly_quota" };
+  // A 400 whose own validator calls the body improperly formed is not proof that the request is
+  // impossible: Kiro answers this shape when the identity a request was routed under cannot serve
+  // it. Treating it as `other` leaves the account selected and the same 400 reaches the client.
+  // Both vendor tokens are required, so a bad payload or a caller echoing one token stays terminal.
+  if (status === 400 && typeof message === "string" && IMPROPER_REQUEST_WORD.test(message)
+    && (reason === VALIDATION_EXCEPTION || message.includes(VALIDATION_EXCEPTION)))
+    return { kind: "profile" };
   if (status === 403 && (reason === "TEMPORARILY_SUSPENDED"
     || (typeof message === "string" && SUSPENSION_WORDS.some(word => message.toLowerCase().includes(word)))))
     return { kind: "suspended" };
   if (status === 429) return { kind: "rate" };
   return { kind: "other" };
 }
+
+/** The adapter's own prefix for a normalized 400 (`normalizedKiroErrorMessage` in kiro-errors.ts). */
+const KIRO_INVALID_REQUEST_PREFIX = "Kiro invalid request: ";
+
+/**
+ * The same verdict at the combo layer. There the text is either the adapter's normalized message
+ * ("Kiro invalid request: ValidationException: Improperly formed request", what a combo child's
+ * failure carries) or a raw JSON body, each possibly behind the "Provider error 400: " frame.
+ * JSON goes through the parsed `reason`/`message` rules of `classifyKiroRefusal` (tokens in
+ * unrelated fields never count); prose counts only behind the adapter's own prefix. Callers must
+ * also know the failed target is a Kiro adapter.
+ */
+export function isKiroAccountProfileRefusal(status: number, bodyText: string): boolean {
+  if (status !== 400 || Buffer.byteLength(bodyText, "utf8") > BOUNDED_BODY_MAX_BYTES) return false;
+  const text = bodyText.replace(/^Provider error \d{3}: /, "");
+  if (text.startsWith(KIRO_INVALID_REQUEST_PREFIX)) {
+    const detail = text.slice(KIRO_INVALID_REQUEST_PREFIX.length);
+    return detail.includes(VALIDATION_EXCEPTION) && IMPROPER_REQUEST_WORD.test(detail);
+  }
+  try {
+    const row: unknown = JSON.parse(text);
+    if (!row || typeof row !== "object" || Array.isArray(row)) return false;
+    const envelope = (row as Record<string, unknown>).error;
+    const body = envelope && typeof envelope === "object" && !Array.isArray(envelope) ? envelope : row;
+    const { reason, message } = body as Record<string, unknown>;
+    return classifyKiroRefusal(400, JSON.stringify({ reason, message })).kind === "profile";
+  } catch { return false; }
+}

package/src/adapters/ollama-native.ts

@@ -290,6 +290,7 @@ function contentToNative(
       text += part.text;
       continue;
     }
+    if (part.type === "audio") throw new Error(`ollama-native cannot send audio content in ${label}`);
     // Ollama's native /api/chat message shape carries `images: string[]` and has no video
     // counterpart, so a video part is refused rather than silently dropped or mis-sent as an image.
     if (part.type === "video") throw new Error(`ollama-native cannot send video content in ${label}`);

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

@@ -27,8 +27,8 @@ const VIDEO_UNSUPPORTED_MARKER = "[video omitted: the translated Chat route has
 /**
  * Chat-completions image_url parts for images carried inside a tool result (issue #888). role:"tool"
  * content is text-only on every chat provider, so these ride in a follow-up user message instead of
- * being flattened to the "[image]" marker the model can't actually see. Data URLs and remote https
- * URLs are both valid in image_url.url, unlike Gemini inline_data which needs base64.
+ * being flattened to the "[image]" marker the model can't actually see. The same follow-up carries
+ * inline audio as input_audio, which is also user-content-only on this wire.
  */
 export function toolResultTextForWire(content: string | OcxContentPart[], annotateEmpty = false): string {
   // An empty content array is a present-but-empty result; `contentPartsToText` would
@@ -63,6 +63,14 @@ export function toolResultImageChatParts(content: string | OcxContentPart[]): un
   return parts;
 }
 
+/** Chat input_audio parts for audio carried inside a tool result. */
+export function toolResultAudioChatParts(content: string | OcxContentPart[]): unknown[] {
+  if (typeof content === "string") return [];
+  return content
+    .filter((p): p is Extract<OcxContentPart, { type: "audio" }> => p.type === "audio")
+    .map(p => ({ type: "input_audio", input_audio: { data: p.data, format: p.format } }));
+}
+
 /**
  * Whether this wire serializes a replayed thinking block for the given model.
  *
@@ -98,6 +106,7 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
   let pendingToolCalls: PendingToolCall[] = [];
   let deferredBarrierMessages: unknown[] = [];
   let pendingToolResultImageParts: unknown[] = [];
+  let pendingToolResultAudioParts: unknown[] = [];
   let mintedIdSeq = 0;
   const seenWireCallIds = new Set<string>();
 
@@ -128,6 +137,18 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
     pendingToolResultImageParts = [];
   };
 
+  const flushToolResultAudio = (): void => {
+    if (pendingToolResultAudioParts.length === 0) return;
+    out.push({
+      role: "user",
+      content: [
+        { type: "text", text: "[ocx] audio output from the preceding tool result(s):" },
+        ...pendingToolResultAudioParts,
+      ],
+    });
+    pendingToolResultAudioParts = [];
+  };
+
   const flushPendingToolCalls = (): void => {
     if (pendingToolCalls.length === 0) return;
     for (const call of pendingToolCalls) {
@@ -139,6 +160,7 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
     }
     pendingToolCalls = [];
     flushToolResultImages();
+    flushToolResultAudio();
     releaseDeferredBarriers();
   };
 
@@ -185,9 +207,10 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
       case "developer": {
         const parts = typeof msg.content === "string" ? undefined : msg.content as OcxContentPart[];
         const hasImages = parts?.some(p => p.type === "image") ?? false;
+        const hasAudio = parts?.some(p => p.type === "audio") ?? false;
         // A document has a structured counterpart on this wire, so it needs the parts array for
         // the same reason an image does: flattening it to a string would drop the bytes.
-        const hasStructured = hasImages || (parts?.some(p => p.type === "document") ?? false);
+        const hasStructured = hasImages || hasAudio || (parts?.some(p => p.type === "document") ?? false);
         let chatMsg: Record<string, unknown>;
         if (msg.role === "developer" && !hasStructured) {
           const text = typeof msg.content === "string"
@@ -219,6 +242,9 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
             if (p.type === "image") {
               return { type: "image_url", image_url: { url: p.imageUrl, ...(p.detail ? { detail: p.detail } : {}) } };
             }
+            if (p.type === "audio") {
+              return { type: "input_audio", input_audio: { data: p.data, format: p.format } };
+            }
             // Chat Completions carries an attached document as a file part with inline bytes,
             // the direct counterpart of the Anthropic document block the caller sent.
             if (p.type === "document") {
@@ -240,7 +266,7 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
           // this wire. One carrying only a document has no such precedent, and demoting it would
           // undo the role this adapter just finished preserving.
           chatMsg = {
-            role: msg.role === "developer" && !hasImages ? developerWireRole : "user",
+            role: msg.role === "developer" && !hasImages && !hasAudio ? developerWireRole : "user",
             content: chatParts,
           };
         }
@@ -330,9 +356,11 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
             content: toolResultTextForWire(msg.content, provider.annotateEmptyToolOutputs === true),
           });
           pendingToolResultImageParts.push(...toolResultImageChatParts(msg.content));
+          pendingToolResultAudioParts.push(...toolResultAudioChatParts(msg.content));
           pendingToolCalls.splice(matchIdx, 1);
           if (pendingToolCalls.length === 0) {
             flushToolResultImages();
+            flushToolResultAudio();
             releaseDeferredBarriers();
           }
         } else {
@@ -380,7 +408,9 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
             content: toolResultTextForWire(msg.content, provider.annotateEmptyToolOutputs === true),
           });
           pendingToolResultImageParts.push(...toolResultImageChatParts(msg.content));
+          pendingToolResultAudioParts.push(...toolResultAudioChatParts(msg.content));
           flushToolResultImages();
+          flushToolResultAudio();
         }
         break;
       }

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

@@ -14,8 +14,11 @@ 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 { planNativeChatReasoningReplay } from "./reasoning-replay";
 import type { OcxReasoningReplayScopeRef } from "../../types";
+import { jsonUtf8Bytes } from "../../lib/json-byte-size";
+import { isTranslatorBudgetExceededError, TRANSLATOR_MAX_TURN_BYTES, TranslatorBudgetExceededError,
+  type TranslatorBudget } from "../../lib/translator-budget";
 
 const CHAT_PASSTHROUGH_FIELDS = [
   "audio",
@@ -58,6 +61,8 @@ export function buildOpenAIChatPassthroughRequest(
   fastMode?: boolean,
   providerName?: string,
   replayScope?: OcxReasoningReplayScopeRef,
+  maxSerializedBytes = TRANSLATOR_MAX_TURN_BYTES,
+  translatorBudget?: TranslatorBudget,
 ): AdapterRequest {
   const { url, headers, hasCredential } = openAIChatTransport(provider);
 
@@ -79,8 +84,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);
+  const replayPlan = planNativeChatReasoningReplay(body.messages, provider, modelId, replayScope,
+    Array.isArray(rawBody.tools) && rawBody.tools.length > 0, maxSerializedBytes);
   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;
@@ -161,7 +166,35 @@ export function buildOpenAIChatPassthroughRequest(
     body.stream_options = rawBody.stream_options;
   }
 
-  const bodyJson = JSON.stringify(applyGithubCopilotContextTier(body, provider, modelId, providerName));
+  const transformedBody = () => applyGithubCopilotContextTier(body, provider, modelId, providerName);
+  // The binding constraint is the final size base + net, so a shrinking replay may legitimately
+  // measure a base above the cap; only a base above max - net makes the result unserializable.
+  let baseBytes = 0;
+  if (replayPlan.hasChanges) {
+    try {
+      baseBytes = jsonUtf8Bytes(transformedBody(), maxSerializedBytes - replayPlan.serializedBytes);
+    } catch (error) {
+      if (isTranslatorBudgetExceededError(error)) {
+        throw new TranslatorBudgetExceededError("request_copies", maxSerializedBytes);
+      }
+      throw error;
+    }
+  }
+  if (replayPlan.serializedBytes > maxSerializedBytes - baseBytes) {
+    throw new TranslatorBudgetExceededError("request_copies", maxSerializedBytes);
+  }
+  const preSerialization = translatorBudget?.reserveTransient(baseBytes + replayPlan.serializedBytes, {
+    kind: "request_copies",
+  });
+  let bodyJson: string;
+  try {
+    if (replayPlan.hasChanges) {
+      body.messages = replayPlan.apply();
+    }
+    bodyJson = JSON.stringify(transformedBody());
+  } finally {
+    preSerialization?.release();
+  }
 
   if (isDebugEnabled()) {
     let host = "upstream";

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

@@ -1,10 +1,14 @@
 import { modelInList, type OcxProviderConfig, type OcxReasoningReplayScopeRef } from "../../types";
 import { peekReasoningForCall } from "../../responses/reasoning-replay-cache";
+import { jsonStringPartsUtf8Bytes, jsonUtf8Bytes } from "../../lib/json-byte-size";
+import { isTranslatorBudgetExceededError, TranslatorBudgetExceededError } from "../../lib/translator-budget";
 
 type Rec = Record<string, unknown>;
 export const isChatRecord = (value: unknown): value is Rec =>
   value !== null && typeof value === "object" && !Array.isArray(value);
 
+const REASONING_CONTENT_FIELD_BYTES = Buffer.byteLength('"reasoning_content":', "utf8");
+
 const isDeepSeekThinkingModel = (modelId: string): boolean =>
   /(?:^|\/)deepseek-(?:v\d+(?:\.\d+)*-(?:flash|pro)|flash|pro)(?:$|[-_:])/i.test(modelId);
 
@@ -25,28 +29,109 @@ export function chatReasoningReplayPolicy(provider: OcxProviderConfig, modelId:
   };
 }
 
-/** Repair missing native history without mutating caller bodies used by retries/combo siblings. */
-export function replayNativeChatReasoning(
+interface ReplayMessagePlan {
+  message: Rec;
+  parts: string[];
+}
+
+export interface NativeChatReasoningReplayPlan {
+  /** Net byte change in the final escaped JSON object representation; may be zero or negative. */
+  readonly serializedBytes: number;
+  /** Whether apply() rewrites any message, independent of the net byte change. */
+  readonly hasChanges: boolean;
+  apply(): unknown[];
+}
+
+/** Preflight escaped replay growth before allocating the copied messages or serialized body. */
+export function planNativeChatReasoningReplay(
   messages: unknown,
   provider: OcxProviderConfig,
   modelId: string,
   scope?: OcxReasoningReplayScopeRef,
   hasTools = false,
-): unknown {
+  maxSerializedBytes = Number.MAX_SAFE_INTEGER,
+): NativeChatReasoningReplayPlan {
   const policy = chatReasoningReplayPolicy(provider, modelId);
   if (!policy.preserve || !Array.isArray(messages)
-      || modelInList(provider.reasoningDetailsModels, modelId)) return messages;
-  return messages.map(message => {
+      || modelInList(provider.reasoningDetailsModels, modelId)) {
+    return { serializedBytes: 0, hasChanges: false, apply: () => messages as unknown[] };
+  }
+  const plans: ReplayMessagePlan[] = [];
+  let serializedBytes = 0;
+  for (const message of messages) {
     if (!isChatRecord(message) || message.role !== "assistant"
-        || (typeof message.reasoning_content === "string" && message.reasoning_content.length > 0)) return message;
+        || (typeof message.reasoning_content === "string" && message.reasoning_content.length > 0)) continue;
     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 };
-  });
+    if (calls.length === 0 && !(hasTools && isDeepSeekThinkingModel(modelId))) continue;
+    const cached = new Set<string>();
+    for (const tool of calls) {
+      if (!isChatRecord(tool) || typeof tool.id !== "string") continue;
+      const text = peekReasoningForCall(tool.id, scope);
+      if (text) cached.add(text);
+    }
+    const parts = cached.size > 0
+      ? [...cached]
+      : policy.placeholder ? [" "] : [];
+    if (parts.length === 0) continue;
+
+    // The envelope delta around the joined value is exact for the plain JSON the Chat
+    // ingress produces: an absent or skipped key adds the reasoning_content field bytes
+    // plus one separator when another field serializes, while an already-serialized key
+    // ("" included) keeps its position and commas, so only the value size changes.
+    const oldReasoning = message.reasoning_content;
+    try {
+      const envelopeDelta = oldReasoning === undefined
+        ? REASONING_CONTENT_FIELD_BYTES
+          + (Object.keys(message).some(key => message[key] !== undefined) ? 1 : 0)
+        : -jsonUtf8Bytes(oldReasoning, Number.MAX_SAFE_INTEGER);
+      const fragments: string[] = [];
+      for (let index = 0; index < parts.length; index++) {
+        if (index > 0) fragments.push("\n");
+        fragments.push(parts[index]!);
+      }
+      const valueBytes = jsonStringPartsUtf8Bytes(
+        fragments,
+        maxSerializedBytes - serializedBytes - envelopeDelta,
+      );
+      const added = valueBytes + envelopeDelta;
+      if (added > maxSerializedBytes - serializedBytes) {
+        throw new TranslatorBudgetExceededError("request_copies", maxSerializedBytes);
+      }
+      serializedBytes += added;
+    } catch (error) {
+      // Inner measurements cap at the remaining budget; report the caller's real limit.
+      if (isTranslatorBudgetExceededError(error)) {
+        throw new TranslatorBudgetExceededError("request_copies", maxSerializedBytes);
+      }
+      throw error;
+    }
+    plans.push({ message, parts });
+  }
+  return {
+    serializedBytes,
+    hasChanges: plans.length > 0,
+    apply: () => {
+      if (plans.length === 0) return messages;
+      const byMessage = new Map(plans.map(plan => [plan.message, plan.parts]));
+      return (messages as unknown[]).map(message => {
+        if (!isChatRecord(message)) return message;
+        const parts = byMessage.get(message);
+        if (!parts) return message;
+        return { ...message, reasoning_content: parts.join("\n") };
+      });
+    },
+  };
+}
+
+/** 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 {
+  return planNativeChatReasoningReplay(messages, provider, modelId, scope, hasTools).apply();
 }