@bitkyc08/opencodex 2.89.0 → 2.91.0

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();
 }