@bitkyc08/opencodex 2.65.0 → 2.66.0-preview.20260925

package/src/adapters/openai-chat/serialized-tool-call-content.ts

@@ -1,5 +1,6 @@
 import type { TranslatorBudget } from "../../lib/translator-budget";
 import type { AdapterEvent } from "../../types";
+import { repairFreeformToolInput } from "../../responses/apply-patch-envelope";
 
 const OPEN_TAG = "<tool_call>";
 const CLOSE_TAG = "</tool_call>";
@@ -27,9 +28,24 @@ export interface SerializedToolCall {
   end: number;
 }
 
+/** A freeform tool's declared identity. Echoes are matched against it, never against the wire alias. */
+export interface FreeformToolIdentity {
+  name: string;
+  namespace?: string;
+}
+
+/** The request's freeform tools keyed by the wire name the provider sees for each of them. */
+export function freeformToolsByWireName<T extends FreeformToolIdentity & { freeform?: boolean }>(
+  tools: readonly T[] | undefined,
+  wireName: (tool: T) => string,
+): Map<string, FreeformToolIdentity> {
+  return new Map(tools?.filter(tool => tool.freeform).map(tool => [wireName(tool), { name: tool.name, namespace: tool.namespace }] as const) ?? []);
+}
+
 export interface StructuredToolCallReference {
   names: ReadonlySet<string>;
   argumentsText: string;
+  freeformTool?: FreeformToolIdentity;
 }
 
 const BLOCK_HEADER = /<tool_call>\s*<function=([^>\r\n]+)>/y;
@@ -176,6 +192,29 @@ function contextAfter(text: string, context: TextContext): TextContext {
   return splitAtPossibleSerializedToolCall(text.replaceAll(OPEN_TAG, "<tool-call>"), context, true).context;
 }
 
+/**
+ * A deferred header/fence can itself be long. While its unresolved portion only grows, a
+ * chunk-local check suffices; the first resolving character goes back through the full splitter.
+ * Each unbounded phase is scanned once on entry and once on exit, preserving its Markdown rules.
+ */
+function deferredContinuationBreak(text: string, context: TextContext): RegExp | undefined {
+  if (text.startsWith(OPEN_TAG)) {
+    if (/^<tool_call>\s*$/.test(text)) return /\S/;
+    if (/^<tool_call>\s*<function=[^>\r\n]*$/.test(text)) return /[>\r\n]/;
+  }
+  if (!context.inlineTicks && context.lineStart) {
+    const fence = /^ {0,3}(`{3,}|~{3,})([^\n]*)$/.exec(text);
+    if (fence) {
+      if (!context.fence) return /\n/;
+      // Closing-fence ticks may grow only before its optional whitespace suffix.
+      if (!fence[2]) return fence[1]![0] === "`" ? /[^`]/ : /[^~]/;
+      return /[^ \t\r]/;
+    }
+  }
+  if (/^`+$/.test(text)) return /[^`]/;
+  return undefined;
+}
+
 /**
  * Holds possible duplicate text within the shared translator budget until the dispatch outcome is
  * known. While a block candidate is open, any other event (reasoning) is queued at its position in
@@ -186,11 +225,30 @@ export class SerializedToolCallContentBuffer {
   private text = "";
   private bytes = 0;
   private hasOpenTag = false;
+  private continuationBreak: RegExp | undefined;
+  private delimiterSuffix = "";
+  private sawCloser = false;
+  private openAfterCloser = false;
+  private trailingProseChars = 0;
   private context: TextContext = { fence: null, lineStart: true };
   private queued: { offset: number; event: AdapterEvent }[] = [];
 
   constructor(private readonly budget: TranslatorBudget) {}
 
+  /** Measures an append exactly even when the runtime prices isolated UTF-16 surrogates differently. */
+  private appendedByteLength(delta: string): number {
+    let bytes = Buffer.byteLength(delta);
+    if (this.text.length === 0 || delta.length === 0) return bytes;
+    const tail = this.text[this.text.length - 1]!;
+    const head = delta[0]!;
+    const tailCode = tail.charCodeAt(0);
+    const headCode = head.charCodeAt(0);
+    if (tailCode >= 0xd800 && tailCode <= 0xdbff && headCode >= 0xdc00 && headCode <= 0xdfff) {
+      bytes += Buffer.byteLength(tail + head) - Buffer.byteLength(tail) - Buffer.byteLength(head);
+    }
+    return bytes;
+  }
+
   /** Reserves the replacement before releasing the old text, preserving it if the budget rejects growth. */
   private replace(next: string, hasOpenTag: boolean): void {
     const nextBytes = Buffer.byteLength(next);
@@ -201,6 +259,12 @@ export class SerializedToolCallContentBuffer {
       this.text = next;
       this.bytes = nextBytes;
       this.hasOpenTag = hasOpenTag;
+      this.continuationBreak = undefined;
+      this.delimiterSuffix = "";
+      this.sawCloser = false;
+      this.openAfterCloser = false;
+      this.trailingProseChars = 0;
+      if (hasOpenTag) this.observeDelimiters(next);
     } catch (error) {
       reservation.release();
       throw error;
@@ -209,21 +273,41 @@ export class SerializedToolCallContentBuffer {
 
   /** Charges only the appended bytes, so holding an open block never needs twice its retained size. */
   private append(delta: string): void {
-    const deltaBytes = Buffer.byteLength(delta);
+    const deltaBytes = this.appendedByteLength(delta);
     this.budget.reserveTransient(deltaBytes, { kind: "live_transient" }).commitRetained();
+    if (this.hasOpenTag) this.observeDelimiters(delta);
     this.text += delta;
     this.bytes += deltaBytes;
   }
 
+  /** Scan new text plus a fixed overlap, never the retained body (which may be a large rope). */
+  private observeDelimiters(delta: string): void {
+    const scan = this.delimiterSuffix + delta;
+    const closer = scan.lastIndexOf(CLOSE_TAG);
+    const afterCloser = closer + CLOSE_TAG.length;
+    if (closer >= 0) {
+      this.sawCloser = true;
+      this.openAfterCloser = false;
+      this.trailingProseChars = 0;
+    }
+    if (scan.lastIndexOf(OPEN_TAG) >= (closer >= 0 ? afterCloser : 0)) {
+      this.openAfterCloser = true;
+    }
+    const tail = closer >= 0 ? scan.slice(afterCloser) : delta;
+    if (this.sawCloser) this.trailingProseChars += tail.replace(/\s+/g, "").length;
+    this.delimiterSuffix = scan.slice(-(Math.max(OPEN_TAG.length, CLOSE_TAG.length) - 1));
+  }
+
   /** Returns immediately safe text and retains only the suffix that still needs reconciliation. */
   ingest(delta: string): string {
-    if (this.hasOpenTag) {
+    if (this.hasOpenTag || (this.continuationBreak && !this.continuationBreak.test(delta))) {
       this.append(delta);
       return "";
     }
     const split = splitAtPossibleSerializedToolCall(this.text + delta, this.context);
     this.replace(split.defer, split.hasOpenTag);
     this.context = split.context;
+    if (!split.hasOpenTag) this.continuationBreak = deferredContinuationBreak(split.defer, split.context);
     return split.emit;
   }
 
@@ -234,11 +318,11 @@ export class SerializedToolCallContentBuffer {
    * context. The size bound is checked before the delta is retained.
    */
   ingestStreaming(delta: string): AdapterEvent[] {
-    const deltaBytes = Buffer.byteLength(delta);
+    const deltaBytes = this.appendedByteLength(delta);
     if (this.hasOpenTag && this.bytes + deltaBytes > MAX_HELD_BYTES) {
       const released = this.drain([]);
       // A delta that alone passes the bound is delivered as text rather than retained.
-      if (deltaBytes > MAX_HELD_BYTES) {
+      if (Buffer.byteLength(delta) > MAX_HELD_BYTES) {
         this.context = contextAfter(delta, this.context);
         return [...released, ...textEvents(delta)];
       }
@@ -246,7 +330,7 @@ export class SerializedToolCallContentBuffer {
     }
     const text = this.ingest(delta);
     // Checked after ingest too: one delta can open a block and already carry more than a bound.
-    if (this.hasOpenTag && (this.bytes > MAX_HELD_BYTES || proseAfterClosedBlock(this.text) > MAX_TRAILING_CHARS)) {
+    if (this.hasOpenTag && (this.bytes > MAX_HELD_BYTES || (this.sawCloser && !this.openAfterCloser && this.trailingProseChars > MAX_TRAILING_CHARS))) {
       return [...textEvents(text), ...this.drain([])];
     }
     return textEvents(text);
@@ -318,20 +402,30 @@ export class SerializedToolCallContentBuffer {
     this.text = "";
     this.bytes = 0;
     this.hasOpenTag = false;
+    this.continuationBreak = undefined;
     this.queued = [];
   }
 }
 
-/** Reads only a string input from a JSON object; other argument shapes cannot prove duplication. */
-function inputFromArguments(argumentsText: string): string | undefined {
+/** Reads a wrapped input or raw arguments from a declared freeform tool; neither path rewrites them. */
+function inputFromArguments(
+  argumentsText: string,
+  freeformTool?: FreeformToolIdentity,
+): string | undefined {
   try {
     const parsed = JSON.parse(argumentsText) as unknown;
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
-    const input = (parsed as Record<string, unknown>).input;
-    return typeof input === "string" ? input : undefined;
+    const input = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>).input
+      : undefined;
+    if (typeof input === "string") return input;
   } catch {
-    return undefined;
+    // Chat gateways can send custom-tool input as raw text.
   }
+  if (!freeformTool) return undefined;
+  // Match raw input only when the Responses bridge dispatches these same bytes. It can unwrap
+  // alternate fields or repair freeform input using the declared tool's name and namespace.
+  return repairFreeformToolInput(argumentsText, freeformTool.name, freeformTool.namespace) === argumentsText
+    ? argumentsText : undefined;
 }
 
 /** One wrapping newline after the function header is template layout, not input (vLLM `_trim_wrapping_newlines`). */
@@ -348,10 +442,20 @@ function agreesWithRepeatedBlock(
   structured: StructuredToolCallReference,
   repeated: SerializedToolCall,
 ): boolean {
-  const input = structured.names.has(repeated.name) ? inputFromArguments(structured.argumentsText) : undefined;
+  const input = structured.names.has(repeated.name) ? inputFromArguments(structured.argumentsText, structured.freeformTool) : undefined;
   return input !== undefined && freeformBody(input) === freeformBody(repeated.body);
 }
 
+/** A second call can explain a repeated pair even when its arguments cannot safely be rewritten. */
+function hasDoubledInput(structured: StructuredToolCallReference, repeated: SerializedToolCall): boolean {
+  if (!structured.names.has(repeated.name)) return false;
+  const input = inputFromArguments(structured.argumentsText, structured.freeformTool);
+  if (input === undefined) return false;
+  const body = freeformBody(repeated.body);
+  const normalized = freeformBody(input);
+  return normalized === body + body || normalized === body + "\n" + body;
+}
+
 /** The `[start, end)` ranges of blocks whose function identity and freeform input match a dispatched call. */
 function duplicatedSerializedToolCallRanges(
   text: string,
@@ -361,14 +465,16 @@ function duplicatedSerializedToolCallRanges(
   if (structuredCalls.length === 0) return [];
   const repeated = repeatedCallIn(text, context);
   if (repeated) {
-    // Without a single agreeing call the pair is ambiguous, so no shape of it is suppressed.
+    // A doubled call beside an agreeing call leaves the pair ambiguous. If reduction was
+    // refused, keep the markup too: otherwise the visible text and executable call disagree.
     const matching = structuredCalls.filter(structured => agreesWithRepeatedBlock(structured, repeated));
-    return matching.length === 1 ? [{ start: repeated.start, end: repeated.end }] : [];
+    const doubled = structuredCalls.some(structured => structured !== matching[0] && hasDoubledInput(structured, repeated));
+    return matching.length === 1 && !doubled ? [{ start: repeated.start, end: repeated.end }] : [];
   }
   return callsIn(text, context).filter(call => {
     const body = freeformBody(call.body);
     return structuredCalls.some(structured => {
-      const input = structured.names.has(call.name) ? inputFromArguments(structured.argumentsText) : undefined;
+      const input = structured.names.has(call.name) ? inputFromArguments(structured.argumentsText, structured.freeformTool) : undefined;
       return input !== undefined && freeformBody(input) === body;
     });
   });
@@ -458,16 +564,16 @@ export interface StructuredToolCallInput {
   wireName: string;
   restoredName: string;
   argumentsText: string;
+  freeformTool?: FreeformToolIdentity;
 }
 
 /**
  * Repairs the arguments of every structured call in one response against the visible text that
  * response carried, and returns them in input order. The per-call prefix repair stands alone,
  * because the markup it proves is matched against that call's own repaired input. The
- * doubled-input reduction is applied only when exactly ONE call in the batch qualifies: it either
- * carries the doubled shape or already agrees with the repeated block body. It rewrites executable
- * arguments, and a second qualifying call leaves the block ambiguous, so the uniqueness proof has
- * to cover the whole batch rather than one call at a time.
+ * doubled-input reduction is applied only when exactly one call in the batch explains the repeated
+ * pair, including doubled shapes that cannot themselves be rewritten. It rewrites executable
+ * arguments, so a second explanatory call leaves the pair ambiguous.
  */
 export function reconcileStructuredToolCalls(
   calls: readonly StructuredToolCallInput[],
@@ -475,7 +581,7 @@ export function reconcileStructuredToolCalls(
 ): StructuredToolCallReference[] {
   const references = calls.map(call => {
     const names = new Set([call.wireName, call.restoredName]);
-    return { names, argumentsText: repairArgumentsDuplicatedBesideSerializedCall(call.argumentsText, names, serializedText) };
+    return { names, freeformTool: call.freeformTool, argumentsText: repairArgumentsDuplicatedBesideSerializedCall(call.argumentsText, names, serializedText) };
   });
   return reduceUnambiguousDoubledInput(references, serializedText);
 }
@@ -486,9 +592,8 @@ export function reconcileStructuredToolCalls(
  * alone. A call whose input already equals the repeated body is a competing explanation, not a
  * bystander: both readings account for the pair and the response never picks one, so a batch with
  * two qualifying calls keeps every argument exactly as sent. The reduction then rewrites nothing,
- * and the markup is left to the range matcher, which suppresses the pair only when exactly one
- * call already agrees. A lone qualifying call is always the doubled one, because a call that
- * already agrees leaves nothing to reduce.
+ * and the range matcher keeps the markup when a doubled call competes with an agreeing call.
+ * An already-agreeing call leaves nothing to reduce.
  */
 function reduceUnambiguousDoubledInput(
   references: readonly StructuredToolCallReference[],
@@ -499,13 +604,14 @@ function reduceUnambiguousDoubledInput(
   const candidates = references.map(reference => ({
     reduction: doubledInputReduction(reference.argumentsText, reference.names, repeated),
     explains: agreesWithRepeatedBlock(reference, repeated),
+    doubled: hasDoubledInput(reference, repeated),
   }));
-  if (candidates.filter(candidate => candidate.explains || candidate.reduction !== undefined).length !== 1) {
+  if (candidates.filter(candidate => candidate.explains || candidate.doubled).length !== 1) {
     return [...references];
   }
   return references.map((reference, index) => {
     const reduction = candidates[index]!.reduction;
-    return reduction === undefined ? reference : { names: reference.names, argumentsText: reduction };
+    return reduction === undefined ? reference : { ...reference, argumentsText: reduction };
   });
 }
 
@@ -558,12 +664,3 @@ export function reconcileSerializedToolCallEvents(
 function textEvents(text: string): AdapterEvent[] {
   return text.length > 0 ? [{ type: "text_delta", text }] : [];
 }
-
-/** Non-whitespace characters after the last closed block, or 0 while a later block is still open. */
-function proseAfterClosedBlock(text: string): number {
-  const closer = text.lastIndexOf(CLOSE_TAG);
-  if (closer < 0) return 0;
-  const tail = text.slice(closer + CLOSE_TAG.length);
-  if (tail.includes(OPEN_TAG)) return 0;
-  return tail.replace(/\s+/g, "").length;
-}

package/src/adapters/openai-chat.ts

@@ -45,7 +45,7 @@ import { messagesToChatFormat } from "./openai-chat/messages";
 import { withOpenAIChatToolNames } from "./openai-chat/tool-name-registry";
 import { openAIChatTransport, stripBracketedModelSuffix } from "./openai-chat/wire";
 import { toolChoiceToChatFormat, toolsToChatFormatForProvider } from "./openai-chat/tool-schema";
-import { reconcileSerializedToolCallEvents, reconcileStructuredToolCall, reconcileStructuredToolCalls, SerializedToolCallContentBuffer } from "./openai-chat/serialized-tool-call-content";
+import { freeformToolsByWireName, type FreeformToolIdentity, reconcileSerializedToolCallEvents, reconcileStructuredToolCall, reconcileStructuredToolCalls, SerializedToolCallContentBuffer } from "./openai-chat/serialized-tool-call-content";
 
 export { stripBracketedModelSuffix } from "./openai-chat/wire";
 export { buildOpenAIChatPassthroughRequest } from "./openai-chat/passthrough";
@@ -93,6 +93,7 @@ function canSerializeOpenAIChatServiceTier(
 
 export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAdapter {
   let lastRequestedModelId: string | undefined;
+  let freeformTools = new Map<string, FreeformToolIdentity>();
   return withOpenAIChatToolNames(toolNames => ({
     name: "openai-chat",
 
@@ -102,6 +103,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       lastRequestedModelId = parsed.modelId;
       const { url, headers, hasCredential } = openAIChatTransport(provider);
       const messages = toolNames.messages(parsed, provider.baseUrl, messagesToChatFormat(parsed, provider));
+      freeformTools = freeformToolsByWireName(parsed.context.tools, tool => toolNames.registry().alias(tool));
       const finish = (): AdapterRequest => {
         const tools = toolsToChatFormatForProvider(parsed, provider, toolNames.registry());
         const toolChoice = toolChoiceToChatFormat(parsed.options.toolChoice, parsed.context.tools, provider, toolNames.registry());
@@ -338,7 +340,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
           }
         }
         // Held markup is released only now, as one batch per response: the doubled-input repair needs every call.
-        const references = reconcileStructuredToolCalls(calls.map(call => ({ wireName: call.name, restoredName: toolNames.restore(call.name), argumentsText: call.args })), toolCallContent.current());
+        const references = reconcileStructuredToolCalls(calls.map(call => ({ wireName: call.name, restoredName: toolNames.restore(call.name), argumentsText: call.args, freeformTool: freeformTools.get(call.name) })), toolCallContent.current());
         calls.forEach((call, index) => { call.args = references[index]!.argumentsText; });
         yield* toolCallContent.drain(references);
         for (const call of calls) {
@@ -773,7 +775,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         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.
-        const structuredCalls: { wireName: string; restoredName: string; argumentsText: string; delta: Extract<AdapterEvent, { type: "tool_call_delta" }> }[] = [];
+        const structuredCalls: { wireName: string; restoredName: string; argumentsText: string; freeformTool?: FreeformToolIdentity; delta: Extract<AdapterEvent, { type: "tool_call_delta" }> }[] = [];
         const rawToolCalls = msg.tool_calls;
         if (rawToolCalls !== undefined && rawToolCalls !== null) {
           if (!Array.isArray(rawToolCalls)) {
@@ -797,7 +799,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
               return [invalidToolCallsEvent(rawToolCalls, "response", usage)];
             }
             const delta: Extract<AdapterEvent, { type: "tool_call_delta" }> = { type: "tool_call_delta", arguments: args };
-            structuredCalls.push({ wireName: name, restoredName: toolNames.restore(name), argumentsText: args, delta });
+            structuredCalls.push({ wireName: name, restoredName: toolNames.restore(name), argumentsText: args, freeformTool: freeformTools.get(name), delta });
             events.push({ type: "tool_call_start", id, name: toolNames.restore(name) }, delta, { type: "tool_call_end" });
           }
         }

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

@@ -474,6 +474,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
                   dropNullContentChannel: !isOpenAiOperatedResponsesDestination(provider),
                   stripEncryptedContent: threadServingIdentityChanged || requiresPlaintextReasoningReplay(provider),
                   dropForeignItemId: parsed._dropForeignReasoningItemIds === true,
+                  requirePlaintextReasoning: requiresPlaintextReasoningReplay(provider),
                 },
               ),
               provider,

package/src/adapters/openai-responses/reasoning.ts

@@ -11,6 +11,37 @@ export function dropResponsesReasoningInputItems(body: unknown): unknown {
   return input.length === body.input.length ? body : { ...body, input };
 }
 
+/** Whether the item already carries a non-empty `reasoning_text` content part. */
+function hasPlaintextReasoningContent(content: unknown): boolean {
+  return Array.isArray(content) && content.some(part =>
+    isPlainObject(part)
+    && part.type === "reasoning_text"
+    && typeof part.text === "string"
+    && part.text.length > 0
+  );
+}
+
+/**
+ * Backfill for a reasoning item that would reach a plaintext-required wire with no
+ * `reasoning_text`: its text lived only in ciphertext the provider cannot read and was
+ * stripped, so replay the item's `summary_text` as `reasoning_text` — real model output,
+ * unlike a fabricated chain — and fall back to the same minimal placeholder the chat
+ * adapter emits for `requiresReasoningPlaceholderModels` (#5421). DeepSeek's thinking
+ * mode answers a bare emptied item with `The reasoning_text in the thinking mode must
+ * be passed back to the API` and aborts the turn.
+ */
+function plaintextReasoningBackfill(rec: Record<string, unknown>): unknown[] {
+  const fromSummary = Array.isArray(rec.summary)
+    ? rec.summary
+        .filter(part => isPlainObject(part)
+          && part.type === "summary_text"
+          && typeof part.text === "string"
+          && part.text.length > 0)
+        .map(part => ({ type: "reasoning_text", text: part.text }))
+    : [];
+  return fromSummary.length > 0 ? fromSummary : [{ type: "reasoning_text", text: " " }];
+}
+
 /**
  * Sanitize reasoning input by field policy, not by preserving each item's shape. Retaining a
  * native `encrypted_content` guarantees only that blob value: `status` is always removed;
@@ -40,6 +71,13 @@ export function sanitizeReasoningInputContent(
      * store this destination cannot read; see `OcxParsedRequest._dropForeignReasoningItemIds`.
      */
     dropForeignItemId?: boolean;
+    /**
+     * The destination documents a strict plaintext-replay contract (DeepSeek's Responses
+     * thinking mode): every reasoning input item must carry `reasoning_text` content.
+     * An item left with none is backfilled from its summary, or with a minimal
+     * placeholder, rather than emitted in the shape the upstream 400s on.
+     */
+    requirePlaintextReasoning?: boolean;
   },
 ): unknown {
   if (!body || typeof body !== "object" || Array.isArray(body)) return body;
@@ -85,9 +123,14 @@ export function sanitizeReasoningInputContent(
     const blankContent = !dropNullContentChannel
       && !opts?.preserveRawReasoningContent
       && (hasRawContent || hasOcxEnvelope);
+    // A strict plaintext-replay destination cannot consume a reasoning item emptied of its
+    // `reasoning_text` — the resumed-subagent shape (#5421), where the text lived only in
+    // ciphertext the provider cannot read. Backfill after every other strip has run.
+    const missingPlaintextReasoning = opts?.requirePlaintextReasoning === true
+      && !hasPlaintextReasoningContent(rec.content);
     if (
       !blankContent && !stripOutputStatus && !stripEncryptedContent && !dropNullContentChannel
-      && !missingSummary && !dropItemId
+      && !missingSummary && !dropItemId && !missingPlaintextReasoning
     ) {
       return item;
     }
@@ -106,6 +149,7 @@ export function sanitizeReasoningInputContent(
     // `preserveResponsesReasoningContent` keep it — deleting valid replay content there breaks
     // continuations after tool calls (issue #875 family).
     if (blankContent) next.content = [];
+    if (missingPlaintextReasoning) next.content = plaintextReasoningBackfill(next);
     return next;
   });
 

package/src/bridge/response-json.ts

@@ -49,7 +49,13 @@ import { bridgeToResponsesSSE } from "./sse";
 export function buildResponseJSON(
   events: AdapterEvent[],
   modelId: string,
-  options?: Parameters<typeof buildResponseJSONWithBudget>[2],
+  options?: Parameters<typeof buildResponseJSONWithBudget>[2] & {
+    /**
+     * False when the body is not what the client receives: a direct client encoder counts its
+     * own relayed frames and folds the same events here only for the completion effects.
+     */
+    recordBufferedDelivery?: boolean;
+  },
 ): Record<string, unknown> {
   // Default-budget safety net: a caller that omits the budget gets a bounded
   // default (disposed with the call), never the unbounded append path.
@@ -58,7 +64,9 @@ export function buildResponseJSON(
     // A buffered turn delivers its whole answer as one body, so nothing calls the per-frame
     // recorder on the SSE bridge. Without this the attempt would persist adapter events with
     // zero relayed ones, which is the loss signal -- raised on every non-streaming request.
-    attemptDeliveryRecorder(options.translatorBudget)?.noteBufferedDelivery(body);
+    if (options.recordBufferedDelivery !== false) {
+      attemptDeliveryRecorder(options.translatorBudget)?.noteBufferedDelivery(body);
+    }
     return body;
   }
   const budget = createTranslatorBudget();