@bitkyc08/opencodex 2.52.0 → 2.53.0-preview.20260913

package/src/adapters/openai-responses.ts

@@ -3,6 +3,7 @@ import { stripBracketedModelSuffix } from "./openai-chat";
 import { normalizeOpenCodeGoAdditionalTools } from "./opencode-go-additional-tools";
 import { isXaiResponsesDestination } from "../providers/xai-transport";
 import { createHash } from "node:crypto";
+import { Buffer } from "node:buffer";
 import type { IncomingMeta, ProviderAdapter } from "./base";
 import { namespacedToolName, type AdapterEvent, type OcxParsedRequest, type OcxProviderConfig, type OcxUsage, type TierDecision } from "../types";
 import { catalogModelSupportsReasoningSummaries } from "../codex/catalog";
@@ -24,6 +25,8 @@ import type { TranslatorBudget } from "../lib/translator-budget";
 import { rewriteRoutedCustomToolsForUpstream } from "../responses/custom-tool-compat";
 import { rewriteRoutedToolSearchForUpstream } from "../responses/tool-search-compat";
 import { rewriteRoutedNamespaceToolsForUpstream } from "../responses/namespace-tool-compat";
+import { preparePlaintextV2AgentMessages } from "../responses/plaintext-v2-agent-messages";
+import { isMetaAiResponsesDestination, rewriteMuseToolNamesForUpstream } from "../responses/muse-tool-name-alias";
 import { openaiResponsesUrl } from "./openai-responses-url";
 import { normalizeResponsesCodeMode } from "./responses-code-mode";
 import { stripUnicodePropertyPatterns } from "./responses-tool-schema";
@@ -332,24 +335,6 @@ function scrubOcxCompactionItems(
   return changed ? { ...body, input } : body;
 }
 
-/**
- * Strip unsupported `reasoning` sub-parameters for native slugs that reject them (e.g. Spark).
- * codex-rs injects `reasoning.context` and `reasoning.summary` based on catalog flags; Spark's
- * backend rejects both. The catalog fix prevents `use_responses_lite` from being set, but this
- * is a defense-in-depth guard so stale on-disk catalogs don't break until the user runs `ocx sync`.
- */
-function stripUnsupportedReasoningParams(body: unknown): unknown {
-  if (!isPlainObject(body)) return body;
-  const model = typeof body.model === "string" ? body.model : "";
-  if (!model.includes("codex-spark")) return body;
-  if (!isPlainObject(body.reasoning)) return body;
-  const reasoning = body.reasoning as Record<string, unknown>;
-  // Spark supports reasoning.effort but rejects context, summary, and generate_summary.
-  const { context: _ctx, summary: _sum, generate_summary: _gs, ...rest } = reasoning;
-  if (_ctx === undefined && _sum === undefined && _gs === undefined) return body;
-  return { ...body, reasoning: Object.keys(rest).length > 0 ? rest : undefined };
-}
-
 /**
  * GPT-5.6 retired the legacy 24-hour retention field, and the ChatGPT backend 400s the whole
  * request when that field is present (issue #2092).
@@ -470,157 +455,10 @@ function normalizeConfiguredReasoningSummaryDelivery(
   };
 }
 
-/**
- * Comprehensive Spark compatibility layer. codex-rs emits five tool types (function,
- * namespace, tool_search, web_search, custom) plus extensions (defer_loading,
- * parallel_tool_calls, tool_search_call/output items). Spark's serving path only
- * supports flat function tools and hosted web_search. This function:
- * - Flattens MCP-style namespace tools → promotes inner functions to top level. The reserved
- *   `functions` group is kept as a group (#3217): Codex 0.147+ sends every ordinary client tool
- *   inside it on Responses Lite, the backend accepts the group as-is, and flattening it changes
- *   what the backend answers with — a `custom_tool_call` carrying `namespace: "exec"`, which
- *   codex-rs concatenates into the unroutable `execexec`. Traced on a live proxy: with the
- *   group intact the same backend returns the bare `exec` call and the turn completes.
- * - Drops unsupported tool types (tool_search, custom)
- * - Strips defer_loading from function tools
- * - Strips namespace from input items
- * - Drops tool_search_call/tool_search_output input items
- * - Sets parallel_tool_calls to false
- */
-function stripSparkCompatibility(body: unknown): unknown {
-  if (!isPlainObject(body)) return body;
-  const model = typeof body.model === "string" ? body.model : "";
-  if (!model.includes("codex-spark")) return body;
-
-  let changed = false;
-
-  const SPARK_SAFE_TOOL_TYPES = new Set(["function", "web_search", "web_search_preview"]);
-  // Inside the reserved group Codex sends freeform `custom` tools (code-mode `exec`) and the
-  // backend accepts them there; the top-level "drop custom" rule stays for flattened groups.
-  const SPARK_SAFE_FUNCTIONS_GROUP_CHILD_TYPES = new Set(["function", "custom"]);
-  const filterSparkFunctionsGroup = (group: Record<string, unknown>): Record<string, unknown> | undefined => {
-    if (!Array.isArray(group.tools)) return undefined;
-    let groupChanged = false;
-    const children: unknown[] = [];
-    for (const child of group.tools) {
-      if (!isPlainObject(child) || typeof child.type !== "string" || !SPARK_SAFE_FUNCTIONS_GROUP_CHILD_TYPES.has(child.type)) {
-        groupChanged = true;
-        continue;
-      }
-      if (child.type === "function" && "defer_loading" in child) {
-        const { defer_loading: _, ...rest } = child;
-        groupChanged = true;
-        children.push(rest);
-        continue;
-      }
-      children.push(child);
-    }
-    if (children.length === 0) return undefined;
-    return groupChanged ? { ...group, tools: children } : group;
-  };
-
-  let tools = body.tools;
-  if (Array.isArray(tools)) {
-    const flattened: unknown[] = [];
-    for (const t of tools) {
-      if (isPlainObject(t) && t.type === "namespace" && t.name === SPARK_RESERVED_FUNCTIONS_NAMESPACE) {
-        const kept = filterSparkFunctionsGroup(t);
-        if (kept !== t) changed = true;
-        if (kept) flattened.push(kept);
-      } else if (isPlainObject(t) && t.type === "namespace") {
-        changed = true;
-        if (Array.isArray(t.tools)) {
-          for (const inner of t.tools) flattened.push(inner);
-        }
-      } else if (isPlainObject(t) && typeof t.type === "string" && !SPARK_SAFE_TOOL_TYPES.has(t.type)) {
-        changed = true;
-      } else {
-        flattened.push(t);
-      }
-    }
-    // Strip defer_loading from promoted/remaining function tools.
-    tools = flattened.map(t => {
-      if (isPlainObject(t) && t.type === "function" && "defer_loading" in t) {
-        const { defer_loading: _, ...rest } = t;
-        changed = true;
-        return rest;
-      }
-      return t;
-    });
-  }
-
-  // Clean input items: strip namespace, drop tool_search_call/tool_search_output.
-  const SPARK_UNSUPPORTED_INPUT_TYPES = new Set([
-    "tool_search_call", "tool_search_output",
-    "custom_tool_call", "custom_tool_call_output",
-  ]);
-  let input = body.input;
-  if (Array.isArray(input)) {
-    const cleaned: unknown[] = [];
-    for (const item of input) {
-      if (isPlainObject(item) && typeof item.type === "string" && SPARK_UNSUPPORTED_INPUT_TYPES.has(item.type)) {
-        changed = true;
-        continue;
-      }
-      // Process additional_tools items: filter their inner tools array the same way.
-      if (isPlainObject(item) && item.type === "additional_tools" && Array.isArray(item.tools)) {
-        const innerTools = item.tools as unknown[];
-        const filteredInner: unknown[] = [];
-        for (const t of innerTools) {
-          if (isPlainObject(t) && t.type === "namespace" && t.name === SPARK_RESERVED_FUNCTIONS_NAMESPACE) {
-            const kept = filterSparkFunctionsGroup(t);
-            if (kept !== t) changed = true;
-            if (kept) filteredInner.push(kept);
-          } else if (isPlainObject(t) && t.type === "namespace") {
-            changed = true;
-            if (Array.isArray(t.tools)) {
-              for (const fn of t.tools) filteredInner.push(fn);
-            }
-          } else if (isPlainObject(t) && typeof t.type === "string" && !SPARK_SAFE_TOOL_TYPES.has(t.type)) {
-            changed = true; // drop custom, tool_search, etc.
-          } else {
-            filteredInner.push(t);
-          }
-        }
-        // Strip defer_loading from remaining function tools.
-        const cleanedInner = filteredInner.map(t => {
-          if (isPlainObject(t) && t.type === "function" && "defer_loading" in t) {
-            const { defer_loading: _, ...rest } = t;
-            changed = true;
-            return rest;
-          }
-          return t;
-        });
-        cleaned.push({ ...item, tools: cleanedInner });
-        continue;
-      }
-      if (isPlainObject(item) && "namespace" in item) {
-        const { namespace: _, ...rest } = item;
-        changed = true;
-        cleaned.push(rest);
-      } else {
-        cleaned.push(item);
-      }
-    }
-    if (changed) input = cleaned;
-  }
-
-  // Force parallel_tool_calls off for Spark.
-  const extraOverrides: Record<string, unknown> = {};
-  if (body.parallel_tool_calls === true) { extraOverrides.parallel_tool_calls = false; changed = true; }
-
-  return changed
-    ? { ...body, ...(tools !== body.tools ? { tools } : {}), ...(input !== body.input ? { input } : {}), ...extraOverrides }
-    : body;
-}
-
 function isPlainObject(v: unknown): v is Record<string, unknown> {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
 
-/** Codex's reserved client-tool group on Responses Lite; carries no wire prefix. */
-const SPARK_RESERVED_FUNCTIONS_NAMESPACE = "functions";
-
 /**
  * Apply the routed provider's real effort ladder to an existing Responses reasoning field.
  * Native forward requests keep the server-owned native clamp; unknown third-party ladders stay
@@ -865,6 +703,7 @@ function promoteClientLoadedTools(body: unknown): unknown {
 }
 
 const MAX_RESPONSES_CALL_ID_LENGTH = 64;
+
 const REPAIRED_CALL_ID_PREFIX = "call_ocx_";
 const REPAIRED_CALL_ID_DIGEST_LENGTH = MAX_RESPONSES_CALL_ID_LENGTH - REPAIRED_CALL_ID_PREFIX.length;
 
@@ -2307,6 +2146,15 @@ function responsesErrorMessage(payload: unknown): string {
   return "upstream compaction failed";
 }
 
+/** Count an append without rescanning accumulated text, including split surrogate pairs. */
+function appendedUtf8Bytes(previousBytes: number, lastCodeUnit: number, fragment: string): number {
+  const first = fragment.charCodeAt(0);
+  // Separate lone surrogates each count as a three-byte replacement character; together
+  // they encode as one four-byte scalar. Empty fragments produce NaN and never pair.
+  const joinsSurrogatePair = lastCodeUnit >= 0xd800 && lastCodeUnit <= 0xdbff && first >= 0xdc00 && first <= 0xdfff;
+  return previousBytes + Buffer.byteLength(fragment, "utf8") - (joinsSurrogatePair ? 2 : 0);
+}
+
 export function createResponsesPassthroughAdapter(provider: OcxProviderConfig): ProviderAdapter & { passthrough: true } {
   return {
     name: "openai-responses",
@@ -2370,6 +2218,9 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
       let routedCustomToolRepairNames: Set<string> | undefined;
       let convertedRoutedToolSearchNames: Set<string> | undefined;
       let convertedRoutedNamespaceToolAliases: Map<string, { namespace: string; name: string; kind: "function" | "custom" }> | undefined;
+      let plaintextV2AgentMessageToolNames: ReadonlySet<string> | undefined;
+      let plaintextV2AgentMessageAliasedToolNames: ReadonlySet<string> | undefined;
+      let convertedMuseToolNameAliases: Map<string, string> | undefined;
       const unexpandedMiss = !!parsed.previousResponseId && parsed._previousResponseInputExpanded !== true;
       let outBody = stripPreviousResponseId(
         parsed._rawBody,
@@ -2463,6 +2314,14 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
           outBody = stripOpenAiOnlyWebSearchFields(outBody);
         }
         outBody = stripMuseSparkUnsupportedWebSearchFields(outBody, parsed.modelId, url);
+        // Host-only: api.meta.ai rejects function names over 64 chars on every Muse model,
+        // including default muse-spark-1.3. Do not reuse the contributor/Zen web_search
+        // predicates. Namespace flattening has already produced the public wire names.
+        if (isMetaAiResponsesDestination(url)) {
+          const rewritten = rewriteMuseToolNamesForUpstream(outBody);
+          outBody = rewritten.body;
+          convertedMuseToolNameAliases = rewritten.aliases;
+        }
         // Last, so promoted namespace children are also cleared of Codex-private fields.
         outBody = stripCanonicalOnlyToolFields(outBody, provider.supportsOpenAiWebSearchToolFields === false);
       }
@@ -2479,34 +2338,38 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
       // Run after routed compaction so nested input_image parts are replaced before a malformed
       // tool output is flattened to text and can no longer be inspected structurally.
       outBody = repairUnidentifiedToolOutputItems(outBody);
+      if (parsed._plaintextV2AgentMessages === true && isCanonicalOpenAiForwardProvider(provider)) {
+        const prepared = preparePlaintextV2AgentMessages(outBody);
+        outBody = prepared.body;
+        if (prepared.namespaceAliased) {
+          plaintextV2AgentMessageToolNames = prepared.toolNames;
+          plaintextV2AgentMessageAliasedToolNames = prepared.aliasedAgentMessageToolNames;
+        }
+      }
       const threadServingIdentityChanged = parsed._stripReasoningEncryptedContent === true;
       const sanitizedBody = normalizeToolSchemas(
-        stripSparkCompatibility(
-          stripUnsupportedReasoningParams(
-            stripItemIdsWhenUnstored(
-              stripInvalidItemIds(
-                stripUnsupportedHostedTools(
-                  sanitizeReasoningInputContent(
-                    scrubOcxCompactionItems(
-                      outBody,
-                      destinationDecodesNativeCompactionBlob(provider),
-                      threadServingIdentityChanged,
-                    ),
-                    {
-                      preserveRawReasoningContent: provider.preserveResponsesReasoningContent === true,
-                      dropNullContentChannel: !isOpenAiOperatedResponsesDestination(provider),
-                      stripEncryptedContent: threadServingIdentityChanged,
-                    },
-                  ),
-                  provider,
+        stripItemIdsWhenUnstored(
+          stripInvalidItemIds(
+            stripUnsupportedHostedTools(
+              sanitizeReasoningInputContent(
+                scrubOcxCompactionItems(
+                  outBody,
+                  destinationDecodesNativeCompactionBlob(provider),
+                  threadServingIdentityChanged,
                 ),
+                {
+                  preserveRawReasoningContent: provider.preserveResponsesReasoningContent === true,
+                  dropNullContentChannel: !isOpenAiOperatedResponsesDestination(provider),
+                  stripEncryptedContent: threadServingIdentityChanged,
+                },
               ),
+              provider,
             ),
           ),
         ),
         isXaiSchemaTarget(provider),
       );
-      const finalBody = stripDisabledVerbosity(
+      const unnormalizedBody = stripDisabledVerbosity(
         stripDisabledReasoningSummaries(
           normalizeConfiguredReasoningSummaryDelivery(sanitizedBody, provider, parsed.modelId),
           provider,
@@ -2515,14 +2378,16 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
         provider,
         parsed.modelId,
       );
+      // Normalize the wire model before deriving model-dependent transport metadata.
+      const finalBody =
+        provider.modelSuffixBracketStrip
+          && unnormalizedBody !== null
+          && typeof unnormalizedBody === "object"
+          && !Array.isArray(unnormalizedBody)
+          && typeof (unnormalizedBody as { model?: unknown }).model === "string"
+          ? { ...(unnormalizedBody as Record<string, unknown>), model: stripBracketedModelSuffix((unnormalizedBody as { model: string }).model) }
+          : unnormalizedBody;
       if (isCanonicalOpenAiForwardProvider(provider)) {
-        // Spark closes Responses Lite streams before a terminal completion. Select compatibility
-        // from the final wire model so aliases cannot leave the caller or a static header enabled.
-        if (isPlainObject(finalBody) && finalBody.model === "gpt-5.3-codex-spark") {
-          for (const name of Object.keys(headers)) {
-            if (name.toLowerCase() === CODEX_RESPONSES_LITE_HEADER) delete headers[name];
-          }
-        }
         const routingHeaders = new Headers(headers);
         applyCodexRoutingHint(routingHeaders, finalBody);
         // Static headers may use mixed casing. Remove every stale spelling
@@ -2548,18 +2413,10 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
       // here, on the serialized body, not on the parsed selector. One place covers both the
       // HTTP and the WebSocket outbound, because the WS path transports this same request
       // instead of rebuilding it.
-      const body = JSON.stringify(
-        provider.modelSuffixBracketStrip
-          && finalBody !== null
-          && typeof finalBody === "object"
-          && !Array.isArray(finalBody)
-          && typeof (finalBody as { model?: unknown }).model === "string"
-          ? { ...(finalBody as Record<string, unknown>), model: stripBracketedModelSuffix((finalBody as { model: string }).model) }
-          : finalBody,
-      );
+      const body = JSON.stringify(finalBody);
       const releaseBodyObservation = translatorBudget.observeExternallyCapped(
         "passthrough_serialization",
-        new TextEncoder().encode(body).byteLength,
+        Buffer.byteLength(body, "utf8"),
       );
       return {
         url,
@@ -2571,6 +2428,9 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
         ...(routedCustomToolRepairNames ? { routedCustomToolRepairNames } : {}),
         ...(convertedRoutedToolSearchNames ? { convertedRoutedToolSearchNames } : {}),
         ...(convertedRoutedNamespaceToolAliases ? { convertedRoutedNamespaceToolAliases } : {}),
+        ...(plaintextV2AgentMessageToolNames ? { plaintextV2AgentMessageToolNames } : {}),
+        ...(plaintextV2AgentMessageAliasedToolNames ? { plaintextV2AgentMessageAliasedToolNames } : {}),
+        ...(convertedMuseToolNameAliases ? { convertedMuseToolNameAliases } : {}),
         ...(tierLog ? { tierLog } : {}),
       };
     },
@@ -2583,12 +2443,18 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
         yield { type: "error", message: "passthrough adapter received no response body" };
         return;
       }
-      const budgetEncoder = new TextEncoder();
       let deltas = "";
+      let deltasBytes = 0;
+      let deltasLastCodeUnit = 0;
       let doneText = "";
+      let doneTextBytes = 0;
+      let doneTextLastCodeUnit = 0;
       let snapshot = "";
+      let snapshotBytes = 0;
       let usage: OcxUsage | undefined;
+      let usageRawBytes = 0;
       let compactionEncryptedContent: string | undefined;
+      let compactionEncryptedContentBytes = 0;
       let completedSeen = false;
       for await (const event of decodeServerSentEvents(response.body, { translatorBudget: budget })) {
         let payload: unknown;
@@ -2598,21 +2464,25 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
           case "response.output_text.delta":
             if (typeof payload.delta === "string") {
               const next = deltas + payload.delta;
-              const previousBytes = budgetEncoder.encode(deltas).byteLength;
-              const reservation = budget.reserveTransient(budgetEncoder.encode(next).byteLength, { kind: "retained_collectors" });
+              const nextBytes = appendedUtf8Bytes(deltasBytes, deltasLastCodeUnit, payload.delta);
+              const reservation = budget.reserveTransient(nextBytes, { kind: "retained_collectors" });
               deltas = next;
               reservation.commitRetained();
-              budget.releaseRetained(previousBytes, { kind: "retained_collectors" });
+              budget.releaseRetained(deltasBytes, { kind: "retained_collectors" });
+              deltasBytes = nextBytes;
+              if (payload.delta.length > 0) deltasLastCodeUnit = payload.delta.charCodeAt(payload.delta.length - 1);
             }
             break;
           case "response.output_text.done":
             if (typeof payload.text === "string") {
               const next = doneText + payload.text;
-              const previousBytes = budgetEncoder.encode(doneText).byteLength;
-              const reservation = budget.reserveTransient(budgetEncoder.encode(next).byteLength, { kind: "retained_collectors" });
+              const nextBytes = appendedUtf8Bytes(doneTextBytes, doneTextLastCodeUnit, payload.text);
+              const reservation = budget.reserveTransient(nextBytes, { kind: "retained_collectors" });
               doneText = next;
               reservation.commitRetained();
-              budget.releaseRetained(previousBytes, { kind: "retained_collectors" });
+              budget.releaseRetained(doneTextBytes, { kind: "retained_collectors" });
+              doneTextBytes = nextBytes;
+              if (payload.text.length > 0) doneTextLastCodeUnit = payload.text.charCodeAt(payload.text.length - 1);
             }
             break;
           case "response.failed":
@@ -2630,28 +2500,28 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
               const compaction = output.find(item => isPlainObject(item) && item.type === "compaction");
               if (isPlainObject(compaction) && typeof compaction.encrypted_content === "string") {
                 const nextEncryptedContent = compaction.encrypted_content;
-                const previousBytes = budgetEncoder.encode(compactionEncryptedContent ?? "").byteLength;
-                const reservation = budget.reserveTransient(budgetEncoder.encode(nextEncryptedContent).byteLength, { kind: "retained_collectors" });
+                const nextEncryptedContentBytes = Buffer.byteLength(nextEncryptedContent, "utf8");
+                const reservation = budget.reserveTransient(nextEncryptedContentBytes, { kind: "retained_collectors" });
                 compactionEncryptedContent = nextEncryptedContent;
                 reservation.commitRetained();
-                budget.releaseRetained(previousBytes, { kind: "retained_collectors" });
+                budget.releaseRetained(compactionEncryptedContentBytes, { kind: "retained_collectors" });
+                compactionEncryptedContentBytes = nextEncryptedContentBytes;
               }
               const next = responsesPayloadText(payload.response);
-              const previousBytes = budgetEncoder.encode(snapshot).byteLength;
-              const reservation = budget.reserveTransient(budgetEncoder.encode(next).byteLength, { kind: "retained_collectors" });
+              const nextBytes = Buffer.byteLength(next, "utf8");
+              const reservation = budget.reserveTransient(nextBytes, { kind: "retained_collectors" });
               snapshot = next;
               reservation.commitRetained();
-              budget.releaseRetained(previousBytes, { kind: "retained_collectors" });
+              budget.releaseRetained(snapshotBytes, { kind: "retained_collectors" });
+              snapshotBytes = nextBytes;
             }
             {
               const nextUsage = usageFromResponsesPayload(payload.response);
               // The attached raw usage object can be event-sized (unknown keys carry arbitrary
               // values); it stays reachable until the terminal yields, so charge it like the
               // adjacent retained collectors or it would defeat the per-request memory cap.
-              const previousRawBytes = usage?.rawUsage === undefined ? 0
-                : budgetEncoder.encode(JSON.stringify(usage.rawUsage)).byteLength;
               const nextRawBytes = nextUsage?.rawUsage === undefined ? 0
-                : budgetEncoder.encode(JSON.stringify(nextUsage.rawUsage)).byteLength;
+                : Buffer.byteLength(JSON.stringify(nextUsage.rawUsage), "utf8");
               if (nextRawBytes > 0) {
                 const reservation = budget.reserveTransient(nextRawBytes, { kind: "retained_collectors" });
                 usage = nextUsage;
@@ -2659,9 +2529,10 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
               } else {
                 usage = nextUsage;
               }
-              if (previousRawBytes > 0) {
-                budget.releaseRetained(previousRawBytes, { kind: "retained_collectors" });
+              if (usageRawBytes > 0) {
+                budget.releaseRetained(usageRawBytes, { kind: "retained_collectors" });
               }
+              usageRawBytes = nextRawBytes;
             }
             break;
         }
@@ -2683,10 +2554,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
       const text = snapshot || doneText || deltas;
       if (text) yield { type: "text_delta", text };
       budget.releaseRetained(
-        budgetEncoder.encode(deltas).byteLength
-          + budgetEncoder.encode(doneText).byteLength
-          + budgetEncoder.encode(snapshot).byteLength
-          + (usage?.rawUsage === undefined ? 0 : budgetEncoder.encode(JSON.stringify(usage.rawUsage)).byteLength),
+        deltasBytes + doneTextBytes + snapshotBytes + usageRawBytes,
         { kind: "retained_collectors" },
       );
       yield {
@@ -2701,7 +2569,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
       try { payload = await response.json(); } catch {
         return [{ type: "error", message: "malformed upstream compaction response" }];
       }
-      budget.chargeRetained(new TextEncoder().encode(JSON.stringify(payload)).byteLength, { kind: "retained_collectors" });
+      budget.chargeRetained(Buffer.byteLength(JSON.stringify(payload), "utf8"), { kind: "retained_collectors" });
       if (!isPlainObject(payload)) {
         return [{ type: "error", message: "malformed upstream compaction response" }];
       }

package/src/adapters/registry.ts

@@ -6,7 +6,6 @@ import { createCodeBuddyAdapter } from "./codebuddy/adapter";
 import { createQoderAdapter } from "./qoder/adapter";
 import { createCommandCodeAdapter } from "./command-code";
 import { createCursorAdapter } from "./cursor";
-import { createDevinCliAdapter } from "./devin-cli/adapter";
 import { createDevinAdapter } from "./devin";
 import { createGoogleAdapter } from "./google";
 import { createKiroAdapter } from "./kiro";
@@ -43,7 +42,6 @@ export type AdapterWire =
   | "google"
   | "kiro"
   | "cursor"
-  | "devin-cli"
   | "devin";
 
 export type AdapterMutationContract =
@@ -126,11 +124,6 @@ export const ADAPTER_REGISTRY = {
     mutation: "codex-owned-with-gated-native-fallback",
     create: (provider: OcxProviderConfig, _context: AdapterFactoryContext) => createCursorAdapter(provider),
   },
-  "devin-cli": {
-    wire: "devin-cli",
-    mutation: "codex-owned",
-    create: (provider: OcxProviderConfig, _context: AdapterFactoryContext) => createDevinCliAdapter(provider),
-  },
   devin: {
     wire: "devin",
     mutation: "codex-owned",

package/src/adapters/run-turn-queue.ts

@@ -12,7 +12,13 @@ export const PREFLIGHT_HEARTBEAT_RETAIN_LIMIT = 16;
 export const COALESCE_MAX_CHUNK_LENGTH = 64 * 1024;
 
 export interface AdapterEventQueue {
-  push(event: AdapterEvent): void;
+  /**
+   * Returns true when the event was merged into the buffered tail instead of
+   * becoming its own retained item. A caller that charges a memory budget for
+   * what the queue holds needs that distinction: a merged delta costs only its
+   * appended payload, while a new item costs a whole serialized event.
+   */
+  push(event: AdapterEvent): boolean;
   close(): void;
   stream(): AsyncIterable<AdapterEvent>;
   collect(): Promise<AdapterEvent[]>;
@@ -98,21 +104,22 @@ export function createAdapterEventQueue(opts?: {
     return false;
   };
 
-  const push = (event: AdapterEvent): void => {
-    if (closed) return;
+  const push = (event: AdapterEvent): boolean => {
+    if (closed) return false;
     const reader = readers.shift();
     if (reader) {
       reader({ done: false, value: event });
-      return;
+      return false;
     }
-    if (coalesceIntoTail(event)) return;
+    if (coalesceIntoTail(event)) return true;
     if (queued.length >= maxBacklog) {
       opts?.onBacklogExceeded?.();
       queued.push({ type: "error", message: "consumer stalled: adapter event backlog exceeded — turn aborted" });
       close();
-      return;
+      return false;
     }
     queued.push(event);
+    return false;
   };
 
   const close = (): void => {

package/src/bridge.ts

@@ -663,16 +663,13 @@ export function bridgeToResponsesSSE(
       const closeCurrentRawReasoning = () => {
         if (!currentRawReasoning) return;
         rawReasoningForNextToolCall = currentRawReasoning.text;
-        emit("response.reasoning_summary_text.done", {
-          item_id: currentRawReasoning.itemId, output_index: currentRawReasoning.outputIndex, summary_index: 0, text: currentRawReasoning.text,
-        });
-        emit("response.reasoning_summary_part.done", {
-          item_id: currentRawReasoning.itemId, output_index: currentRawReasoning.outputIndex, summary_index: 0,
-          part: { type: "summary_text", text: currentRawReasoning.text },
+        emit("response.reasoning_text.done", {
+          item_id: currentRawReasoning.itemId, output_index: currentRawReasoning.outputIndex, content_index: 0, text: currentRawReasoning.text,
         });
         const item = {
           type: "reasoning", id: currentRawReasoning.itemId,
-          summary: [{ type: "summary_text", text: currentRawReasoning.text }],
+          summary: [] as never[],
+          content: [{ type: "reasoning_text", text: currentRawReasoning.text }],
         };
         emit("response.output_item.done", { output_index: currentRawReasoning.outputIndex, item });
         retainFinishedItem(item as OutputItem, currentRawReasoning.textBytes, "reasoning");
@@ -1111,10 +1108,6 @@ export function bridgeToResponsesSSE(
                 const itemId = `rs_${uuid()}`;
                 const item = { type: "reasoning", id: itemId, summary: [] as { type: string; text: string }[] };
                 emit("response.output_item.added", { output_index: outputIndex, item });
-                emit("response.reasoning_summary_part.added", {
-                  item_id: itemId, output_index: outputIndex, summary_index: 0,
-                  part: { type: "summary_text", text: "" },
-                });
                 currentRawReasoning = { itemId, outputIndex, text: "", textBytes: 0 };
               }
               ({ value: currentRawReasoning.text, bytes: currentRawReasoning.textBytes } = appendString(
@@ -1123,9 +1116,12 @@ export function bridgeToResponsesSSE(
                 event.text,
                 "reasoning",
               ));
-              emit("response.reasoning_summary_text.delta", {
+              // Raw reasoning (openai-chat reasoning_content, kiro tags) rides the CONTENT
+              // channel. Clients control raw-reasoning display; this text is not a
+              // provider-authored summary.
+              emit("response.reasoning_text.delta", {
                 item_id: currentRawReasoning.itemId, output_index: currentRawReasoning.outputIndex,
-                summary_index: 0, delta: event.text,
+                content_index: 0, delta: event.text,
               });
               break;
             }
@@ -1297,7 +1293,9 @@ export function bridgeToResponsesSSE(
                 if (isTruncatedStopReason(event.stopReason)) failCurrentToolCall();
                 else closeCurrentToolCall();
               }
-              if (currentWebSearch) closeCurrentWebSearch("completed", []);
+              // A search still in flight when upstream truncates never returned results, so it
+              // takes the same "failed" status as the error/incomplete terminals below.
+              if (currentWebSearch) closeCurrentWebSearch(isTruncatedStopReason(event.stopReason) ? "failed" : "completed", []);
               releasePendingWebSources();
               // Redacted-only turns (or hidden thinking without a trailing signature event) still
               // need their envelope-only reasoning item so the blocks replay next turn.
@@ -1783,7 +1781,8 @@ function buildResponseJSONWithBudget(
     }
     pushOutput({
       type: "reasoning", id: `rs_${uuid()}`,
-      summary: [{ type: "summary_text", text: currentRawReasoning }],
+      summary: [],
+      content: [{ type: "reasoning_text", text: currentRawReasoning }],
     }, currentRawReasoningBytes, "reasoning");
     currentRawReasoning = "";
     currentRawReasoningBytes = 0;

package/src/chat/inbound.ts

@@ -46,10 +46,35 @@ function contentToText(content: unknown): string {
 }
 
 function imageUrlFromPart(part: Rec): string | null {
-  if (part.type !== "image_url") return null;
-  const imageUrl = part.image_url;
-  if (typeof imageUrl === "string" && imageUrl.length > 0) return imageUrl;
-  if (isRec(imageUrl) && typeof imageUrl.url === "string" && imageUrl.url.length > 0) return imageUrl.url;
+  if (part.type === "image_url") {
+    const imageUrl = part.image_url;
+    if (typeof imageUrl === "string" && imageUrl.length > 0) return imageUrl;
+    if (isRec(imageUrl) && typeof imageUrl.url === "string" && imageUrl.url.length > 0) return imageUrl.url;
+    return null;
+  }
+  // Agent clients whose native wire shape is not OpenAI's still send images over
+  // Chat Completions: Pi/MCP-style parts carry {type:"image", data, mimeType}
+  // (Aside read_file tool results), Anthropic-shaped clients carry a source
+  // object. Dropping either silently blinds a vision model, so normalize both
+  // to the URL/data-URI form the Responses pipeline already understands.
+  if (part.type === "image") {
+    const data = part.data;
+    if (typeof data === "string" && data.length > 0) {
+      if (data.startsWith("data:")) return data;
+      const media = typeof part.mimeType === "string" && part.mimeType.length > 0 ? part.mimeType
+        : typeof part.mediaType === "string" && part.mediaType.length > 0 ? part.mediaType
+        : "image/png";
+      return "data:" + media + ";base64," + data;
+    }
+    const source = part.source;
+    if (isRec(source)) {
+      if (source.type === "base64" && typeof source.data === "string" && source.data.length > 0) {
+        const media = typeof source.media_type === "string" && source.media_type.length > 0 ? source.media_type : "image/png";
+        return "data:" + media + ";base64," + source.data;
+      }
+      if (source.type === "url" && typeof source.url === "string" && source.url.length > 0) return source.url;
+    }
+  }
   return null;
 }