@yansigit/opencodex 2.33.0 → 2.35.0

package/src/server/responses/empty-completion-guard.ts

@@ -35,6 +35,41 @@ export function emptyCompletionRetryEnabled(
 /** Surfaced when the single retry was also empty or failed upstream. */
 export const EMPTY_COMPLETION_RETRY_FAILED_CODE = "empty_completion_retry_failed";
 
+/**
+ * Observe an event stream for the empty-completion shape WITHOUT changing it (#2472).
+ *
+ * The guard above is opt-in, so with the default configuration a turn that completes with no
+ * output text and no tool call passes through untouched and the client records a silent
+ * success. That is the reported symptom: an empty result nobody can explain, with no trace
+ * that the proxy saw anything unusual.
+ *
+ * This is deliberately a passthrough observer, not a second guard. Retrying by default would
+ * re-send a turn that may have already had billable side effects; the honest default is to
+ * leave the stream alone and make the occurrence visible, so a user can correlate it and
+ * decide whether to enable the retry.
+ */
+export async function* observeEmptyCompletion(
+  events: AsyncIterable<AdapterEvent>,
+  onEmptyTurn: () => void,
+): AsyncGenerator<AdapterEvent> {
+  let sawContent = false;
+  let sawTerminal = false;
+  for await (const event of events) {
+    // Reasoning is deliberately NOT content, matching the guard: a reasoning-only stream that
+    // ends with nothing is the canonical shape of this failure.
+    if (isContentEvent(event)) sawContent = true;
+    if (isTerminalEvent(event)) {
+      sawTerminal = true;
+      // Only a successful terminal is the silent failure. `error` and `incomplete` are already
+      // a stated outcome the client can render, so flagging them would be noise.
+      if (!sawContent && event.type === "done") onEmptyTurn();
+    }
+    yield event;
+  }
+  // A stream that ends before any terminal is the pre-output EOF variant of the same failure.
+  if (!sawContent && !sawTerminal) onEmptyTurn();
+}
+
 /**
  * Terminal stop reasons the bridge renders as a visible `response.incomplete`
  * (max_tokens / content_filter). Those are already a stated failure, not the

package/src/server/responses/fetch-helpers.ts

@@ -3,6 +3,7 @@ import {
   codexWsUpstreamFetch,
   currentBunRuntimeIdentity,
   shouldUseCodexWsUpstream,
+  type CodexWsUpstreamOptions,
   type BunRuntimeGateInput,
 } from "./ws-upstream";
 import type { OcxProviderConfig } from "../../types";
@@ -73,19 +74,25 @@ export function providerFetch(
     : base;
   const httpFetch = Object.assign(
     (input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) =>
-      transport(input, withUpstreamHttpVersion(input, init, provider)),
+      transport(input, { ...withUpstreamHttpVersion(input, init, provider), timeout: 0 }),
     { preconnect },
   ) as typeof globalThis.fetch;
-  // ChatGPT Codex backend: streaming turns ride the responses_websockets
-  // transport (measured ~3s faster TTFT than the SSE POST queue); everything
-  // else keeps the provider's HTTP fetch. See ws-upstream.ts for the details.
+  // ChatGPT Codex backend: eligible streaming turns stay on HTTP/SSE by
+  // default. `wsUpstream: true`, or (when that option is omitted)
+  // OCX_CODEX_WS_UPSTREAM=true/1, opts into the responses_websockets transport;
+  // everything else keeps the provider's HTTP fetch. See ws-upstream.ts for
+  // the details.
+  const wsOptions: CodexWsUpstreamOptions = {
+    wsUpstream: provider.wsUpstream,
+    maxWsFrameBytes: provider.maxWsFrameBytes,
+  };
   const unpaced = async (input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) => {
-    if (typeof input === "string" && init && shouldUseCodexWsUpstream(input, init, runtime)) {
+    if (typeof input === "string" && init && shouldUseCodexWsUpstream(input, init, runtime, wsOptions)) {
       // The fallback has to be the same HTTP fetch the non-WS branch would have
       // used, protocol pin included: a WS turn that falls back is serving the
       // request over HTTP, and dropping the provider's `upstreamHttpVersion`
       // there would silently negotiate a transport the operator ruled out.
-      return codexWsUpstreamFetch(input, init, httpFetch, runtime);
+      return codexWsUpstreamFetch(input, init, httpFetch, runtime, wsOptions);
     }
     return httpFetch(input, init);
   };
@@ -143,6 +150,7 @@ export async function fetchWithHeaderTimeout(
       // indistinguishable from a pre-connection failure (#914).
       ...(manualRedirect ? { redirect: "manual" as const } : {}),
       signal: AbortSignal.any([abortSignal, timeout.signal]),
+      timeout: 0,
     });
   } finally {
     clearTimeout(timer);

package/src/server/responses/input-admission.ts

@@ -68,7 +68,9 @@ function imageTokens(imageUrl: string): number {
 }
 
 function contentPartTokens(part: OcxContentPart, modelId: string): number {
-  return part.type === "image" ? imageTokens(part.imageUrl) : estimateTokens(part.text, modelId);
+  if (part.type === "image") return imageTokens(part.imageUrl);
+  if (part.type === "video") return imageTokens(part.videoUrl);
+  return estimateTokens(part.text, modelId);
 }
 
 function contentTokens(content: string | readonly OcxContentPart[], modelId: string): number {

package/src/server/responses/passthrough-error.ts

@@ -1,9 +1,29 @@
 import { formatErrorResponse } from "../../bridge";
+import { isCyberPolicyCode, isCyberPolicyMessage } from "../../lib/errors";
 import {
   resolveClientRetryAfter,
   validateClientRetryAfterHeader,
 } from "../../lib/retry-after";
 
+function isCyberPolicyBody(body: string): boolean {
+  if (isCyberPolicyMessage(body)) return true;
+  try {
+    const parsed = JSON.parse(body) as Record<string, unknown>;
+    const response = parsed.response && typeof parsed.response === "object" && !Array.isArray(parsed.response)
+      ? parsed.response as Record<string, unknown>
+      : undefined;
+    for (const candidate of [parsed.error, response?.error, response?.last_error, parsed.last_error, parsed]) {
+      if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) continue;
+      const record = candidate as Record<string, unknown>;
+      if (isCyberPolicyCode(typeof record.code === "string" ? record.code : undefined)) return true;
+      if (typeof record.message === "string" && isCyberPolicyMessage(record.message)) return true;
+    }
+  } catch {
+    /* non-JSON body — message detection above is the only safe fallback */
+  }
+  return false;
+}
+
 /**
  * Passthrough adapters historically relayed upstream non-2xx bodies verbatim.
  * Codex maps an *empty* body to the literal client string "Unknown error"
@@ -32,18 +52,22 @@ export function formatPassthroughUpstreamError(
   const now = options?.now ?? Date.now();
   const upstreamRetryAfter = options?.headers?.get("retry-after")?.trim() || undefined;
   const originalValid = validateClientRetryAfterHeader(upstreamRetryAfter, now);
-  const resolved = resolveClientRetryAfter({
-    status,
-    message: trimmed || `Provider error ${status}: (empty body)`,
-    upstreamRetryAfter,
-    now,
-  });
+  const cyberPolicyFailure = isCyberPolicyBody(trimmed);
+  const resolved = cyberPolicyFailure
+    ? undefined
+    : resolveClientRetryAfter({
+      status,
+      message: trimmed || `Provider error ${status}: (empty body)`,
+      upstreamRetryAfter,
+      now,
+    });
 
   if (trimmed) {
     const needsSet = resolved !== undefined && upstreamRetryAfter !== resolved;
-    const needsDelete = resolved === undefined
-      && upstreamRetryAfter !== undefined
-      && originalValid === undefined;
+    const needsDelete = (cyberPolicyFailure && upstreamRetryAfter !== undefined)
+      || (resolved === undefined
+        && upstreamRetryAfter !== undefined
+        && originalValid === undefined);
 
     if (!needsSet && !needsDelete) {
       return new Response(bodyText, {

package/src/server/responses/policy-fallback.ts

@@ -89,7 +89,7 @@ function finishFailedPolicyAttempt(logCtx: RequestLogContext, status: number): v
   const attempt = logCtx.activeAttempt;
   if (attempt) {
     const startedAt = logCtx.activeAttemptStartedAt ?? Date.now();
-    finishRequestAttempt(attempt, status, Math.max(0, Date.now() - startedAt), attempt.usage ?? logCtx.usage);
+    finishRequestAttempt(attempt, status, Math.max(0, Date.now() - startedAt), attempt.usage ?? logCtx.usage, logCtx.upstreamError);
   }
   delete logCtx.activeAttempt;
   delete logCtx.activeAttemptStartedAt;

package/src/server/responses/responses-field-backfill.ts

@@ -91,6 +91,29 @@ function nextSyntheticItemSlot(): ItemIdSlot {
   return { kind: "fallback", ordinal: syntheticItemOrdinal };
 }
 
+/**
+ * Backfill `status` on a message output item if missing.
+ *
+ * The Responses API spec defines `status` as a required field on
+ * `OutputMessage`. Some upstream relays omit it, which causes strict
+ * deserializers (e.g. grok-build's serde types) to fail with
+ * `missing field 'status'`. Only message items carry this field in the
+ * Responses schema; reasoning, function_call, and other item types do not.
+ *
+ * The value is inferred from the event context: `output_item.added` and
+ * `response.created` / `response.in_progress` mean the message is still
+ * being generated (`in_progress`); `output_item.done` and
+ * `response.completed` / `response.incomplete` mean the message is
+ * finalized (`completed` / `incomplete` respectively).
+ *
+ * Returns the same object reference if no change is needed.
+ */
+function backfillItemStatus(item: Record<string, unknown>, inferredStatus: string): Record<string, unknown> {
+  if (item.type !== "message") return item;
+  if ("status" in item) return item;
+  return { ...item, status: inferredStatus };
+}
+
 /**
  * Backfill annotations: [] on an output_text content part if missing.
  * Returns the same object reference if no change is needed.
@@ -122,10 +145,10 @@ function backfillContentArray(content: unknown): unknown {
 
 /**
  * Walk an output item and backfill output_text parts in its content.
- * Also backfills a missing required id on the item itself.
+ * Also backfills a missing required id and status on the item itself.
  * Returns the same object reference if nothing changed.
  */
-function backfillOutputItem(item: unknown, slot: ItemIdSlot): unknown {
+function backfillOutputItem(item: unknown, slot: ItemIdSlot, inferredStatus: string): unknown {
   if (!isPlainObject(item)) return item;
   // The compact wire family is the `/v1/responses/compact` format, not a Responses output item.
   // Those items have no `id` in that contract, so synthesizing one changes a response body the
@@ -136,34 +159,92 @@ function backfillOutputItem(item: unknown, slot: ItemIdSlot): unknown {
   const content = item.content;
   const repaired = backfillContentArray(content);
   const withId = backfillItemId(item, slot);
-  if (repaired === content && withId === item) return item;
-  return { ...withId, ...(repaired === content ? {} : { content: repaired }) };
+  const withStatus = backfillItemStatus(withId, inferredStatus);
+  if (repaired === content && withStatus === item) return item;
+  return { ...withStatus, ...(repaired === content ? {} : { content: repaired }) };
 }
 
 /**
  * Walk a response object's output[] and backfill output_text parts.
+ *
+ * `inferredItemStatus` is the status to backfill on message items that lack
+ * one — derived from the event type so `output_item.added` / `response.created`
+ * gets `in_progress` while `output_item.done` / `response.completed` gets
+ * `completed`.
+ *
+ * Deliberately does NOT backfill `created_at`. #2639 proposed it for the same
+ * strict-decoder reason as `status`, but the proxy also relays some upstream
+ * responses verbatim, and `tests/server-combo-failover-e2e.test.ts` asserts a
+ * combo backup response is returned byte-exact. Injecting a field the upstream
+ * never sent breaks that contract. Both cannot hold for the same body, so the
+ * `created_at` half needs its own decision about which contract yields; it is
+ * not a detail to slip in beside `status`.
+ *
  * Returns the same object reference if nothing changed.
  */
-function backfillResponseOutput(response: unknown): unknown {
+function backfillResponseOutput(response: unknown, inferredItemStatus: string): unknown {
   if (!isPlainObject(response)) return response;
   const output = response.output;
   if (!Array.isArray(output)) return response;
   let changed = false;
   const repaired = output.map((item, idx) => {
     if (!isPlainObject(item)) return item;
-    const next = backfillOutputItem(item, { kind: "index", index: idx });
+    const next = backfillOutputItem(item, { kind: "index", index: idx }, inferredItemStatus);
     if (next !== item) changed = true;
     return next;
   });
   return changed ? { ...response, output: repaired } : response;
 }
 
+/**
+ * Infer the status to backfill on a message item from the event type.
+ *
+ * `output_item.added` means the item is still being generated (`in_progress`);
+ * `output_item.done` means it is finalized (`completed`). Response-level events
+ * infer from the response's own status field — which is authoritative when present.
+ * If the response status is also absent, the event type itself determines the phase:
+ * `response.created` / `response.in_progress` → `in_progress`,
+ * `response.completed` → `completed`, `response.incomplete` → `incomplete`.
+ */
+function inferredStatusForEventType(eventType: string): string {
+  if (eventType === "response.output_item.added") return "in_progress";
+  if (eventType === "response.output_item.done") return "completed";
+  if (eventType === "response.created" || eventType === "response.in_progress") return "in_progress";
+  // `queued` is a real Responses lifecycle status: the response exists but has not
+  // started generating. Without this row it falls through to the `completed`
+  // default below, which would mark an unstarted message as finished.
+  if (eventType === "response.queued") return "in_progress";
+  if (eventType === "response.incomplete" || eventType === "response.failed") return "incomplete";
+  return "completed";
+}
+
+/**
+ * Map a response-level lifecycle status to a valid OutputMessage status.
+ *
+ * `OutputMessage.status` accepts only `in_progress`, `completed`, or
+ * `incomplete`. Response-level statuses like `failed` or `cancelled` have no
+ * direct message-level equivalent, but `incomplete` is the correct semantic
+ * mapping: the message did not finish generating. Writing `completed` would
+ * assert something the upstream never claimed — a client branching on
+ * `status === "completed"` would treat a truncated message as whole.
+ */
+function messageStatusFromResponseStatus(status: string): string | null {
+  if (status === "in_progress" || status === "completed" || status === "incomplete") return status;
+  // A queued response has not begun generating, so its message items are
+  // in_progress — never completed. Returning null here would fall back to the
+  // event-type inference, whose default is `completed`.
+  if (status === "queued") return "in_progress";
+  if (status === "failed" || status === "cancelled") return "incomplete";
+  return null;
+}
+
 /**
  * Statelessly rewrite one SSE event: backfill annotations
  * on any output_text content part found in the event payload.
  */
 function rewriteEvent(event: Record<string, unknown>): Record<string, unknown> {
   const type = typeof event.type === "string" ? event.type : "";
+  const inferredItemStatus = inferredStatusForEventType(type);
   let next = event;
   let changed = false;
 
@@ -177,8 +258,8 @@ function rewriteEvent(event: Record<string, unknown>): Record<string, unknown> {
     // is not recoverable in that case, but a unique id is what strict decoders require, and a
     // well-formed stream still gets the stable index-derived id.
     const item = typeof rawIndex === "number" && Number.isInteger(rawIndex) && rawIndex >= 0
-      ? backfillOutputItem(event.item, { kind: "index", index: rawIndex })
-      : backfillOutputItem(event.item, nextSyntheticItemSlot());
+      ? backfillOutputItem(event.item, { kind: "index", index: rawIndex }, inferredItemStatus)
+      : backfillOutputItem(event.item, nextSyntheticItemSlot(), inferredItemStatus);
     if (item !== event.item) {
       next = { ...next, item };
       changed = true;
@@ -198,7 +279,13 @@ function rewriteEvent(event: Record<string, unknown>): Record<string, unknown> {
   // response.created / in_progress / completed / incomplete / failed:
   // response.output[].content[] -> output_text parts
   if (isPlainObject(event.response)) {
-    const response = backfillResponseOutput(event.response);
+    // For response-level events, prefer the response's own status when it is a valid
+    // OutputMessage status. Response lifecycle statuses like "failed" or "cancelled"
+    // have no message-level equivalent — fall back to the event-type inference instead.
+    const responseStatus = typeof event.response.status === "string"
+      ? messageStatusFromResponseStatus(event.response.status) ?? inferredItemStatus
+      : inferredItemStatus;
+    const response = backfillResponseOutput(event.response, responseStatus);
     if (response !== event.response) {
       next = { ...next, response };
       changed = true;
@@ -210,9 +297,9 @@ function rewriteEvent(event: Record<string, unknown>): Record<string, unknown> {
 
 /**
  * Create a stateless SSE block rewrite that backfills annotations and
- * on output_text content parts. Unconditional: the field is a required
- * canonical Responses field, so adding it when absent is safe for all
- * clients.
+ * message status on output_text content parts and message items.
+ * Unconditional: both are required canonical Responses fields, so adding
+ * them when absent is safe for all clients.
  */
 export function createResponsesFieldBackfillBlockRewrite(): SseBlockRewrite {
   const rewrite: SseBlockRewrite = (block: string): readonly string[] => {
@@ -245,7 +332,12 @@ export function backfillResponsesFieldsJson(payload: string): string {
     return payload;
   }
   if (!isPlainObject(response)) return payload;
-  const repaired = backfillResponseOutput(response);
+  // For a non-streaming response, derive the item status from the response's own
+  // status field when it is a valid OutputMessage status; fall back to "completed".
+  const inferredItemStatus = typeof response.status === "string"
+    ? messageStatusFromResponseStatus(response.status) ?? "completed"
+    : "completed";
+  const repaired = backfillResponseOutput(response, inferredItemStatus);
   if (repaired === response) return payload;
   return JSON.stringify(repaired);
 }

package/src/server/responses/ws-upstream.ts

@@ -4,8 +4,8 @@
 // a measurably faster queue than the plain SSE POST path. Measured 2026-08-12
 // KST (same account, same payload, strictly sequential): gpt-5.6-luna TTFT p50
 // ~1.0s over WS vs ~3.9s over SSE. Codex CLI itself defaults to the WS
-// transport; opencodex previously always POSTed SSE, which is where its extra
-// 2-3s of TTFT came from.
+// transport; opencodex keeps HTTP/SSE as its reliable default and allows
+// operators to opt into WS when the lower latency is worth the risk.
 //
 // The wrapper only swaps the transport. It dials wss:// with the same headers,
 // sends the JSON body as a single `response.create` frame, and re-encodes the
@@ -14,6 +14,7 @@
 
 import { MAX_CLIENT_SSE_FRAME_BYTES } from "../sse-frame-buffer";
 import { compareBunVersions } from "../../lib/bun-stream-caps";
+import { interceptRuntimeFailure } from "../../telemetry/hook";
 
 const CODEX_RESPONSES_HTTP_URL = "https://chatgpt.com/backend-api/codex/responses";
 const CODEX_RESPONSES_WS_URL = "wss://chatgpt.com/backend-api/codex/responses";
@@ -55,6 +56,29 @@ export type BunRuntimeIdentity = {
 
 export type BunRuntimeGateInput = string | BunRuntimeIdentity;
 
+export interface CodexWsUpstreamOptions {
+  wsUpstream?: boolean;
+  maxWsFrameBytes?: number;
+}
+
+export function isCodexWsUpstreamDisabled(options?: CodexWsUpstreamOptions): boolean {
+  if (options?.wsUpstream !== undefined) return options.wsUpstream !== true;
+  const env = process.env.OCX_CODEX_WS_UPSTREAM;
+  return env !== "true" && env !== "1";
+}
+
+export function resolveCodexWsMaxFrameBytes(options?: CodexWsUpstreamOptions): number {
+  if (typeof options?.maxWsFrameBytes === "number" && Number.isFinite(options.maxWsFrameBytes) && options.maxWsFrameBytes > 0) {
+    return Math.min(options.maxWsFrameBytes, CODEX_WS_CREATE_FRAME_LIMIT_BYTES);
+  }
+  const envVal = process.env.OCX_CODEX_WS_MAX_FRAME_BYTES;
+  if (envVal) {
+    const parsed = Number.parseInt(envVal, 10);
+    if (Number.isFinite(parsed) && parsed > 0) return Math.min(parsed, CODEX_WS_CREATE_FRAME_LIMIT_BYTES);
+  }
+  return CODEX_WS_CREATE_FRAME_LIMIT_BYTES;
+}
+
 const codexWsUpstreamResponses = new WeakSet<Response>();
 
 /** True only for a successful Codex WebSocket upgrade, never an HTTP fallback. */
@@ -102,7 +126,9 @@ export function shouldUseCodexWsUpstream(
   url: string,
   init?: RequestInit,
   runtime: BunRuntimeGateInput = currentBunRuntimeIdentity(),
+  options?: CodexWsUpstreamOptions,
 ): boolean {
+  if (isCodexWsUpstreamDisabled(options)) return false;
   if (!bunSupportsBoundedCodexWsRelay(runtime)) return false;
   if (url !== CODEX_RESPONSES_HTTP_URL) return false;
   if ((init?.method ?? "GET").toUpperCase() !== "POST") return false;
@@ -172,8 +198,9 @@ export function codexWsUpstreamFetch(
   init: RequestInit,
   sseFallback: typeof globalThis.fetch,
   runtime: BunRuntimeGateInput = currentBunRuntimeIdentity(),
+  options?: CodexWsUpstreamOptions,
 ): Promise<Response> {
-  if (!bunSupportsBoundedCodexWsRelay(runtime)) {
+  if (isCodexWsUpstreamDisabled(options) || !bunSupportsBoundedCodexWsRelay(runtime)) {
     return sseFallback(url, init);
   }
   const signal = init.signal ?? undefined;
@@ -196,7 +223,8 @@ export function codexWsUpstreamFetch(
   // streaming Response, so the oversized close can only be surfaced as a stream
   // error — and a resend at that point could double-generate. Measuring the
   // frame we are about to send keeps the whole failure mode unreachable.
-  if (codexWsCreateFrameExceedsLimit(frameText)) {
+  const maxFrameBytes = resolveCodexWsMaxFrameBytes(options);
+  if (codexWsCreateFrameExceedsLimit(frameText, maxFrameBytes)) {
     return sseFallback(url, init);
   }
 
@@ -370,7 +398,9 @@ export function codexWsUpstreamFetch(
         // here would reach clients with no response.completed/failed at all —
         // relaySseWithFailedTail() only synthesizes a failed terminal when the
         // body read THROWS. Error the stream like a reset TCP socket.
-        try { controller.error(new Error(closedBeforeTerminalMessage(event))); } catch { /* stream already done */ }
+        const error = new Error(closedBeforeTerminalMessage(event));
+        if ((event as { code?: unknown } | null)?.code === 1006) interceptRuntimeFailure(error, { category: "websocket_1006" });
+        try { controller.error(error); } catch { /* stream already done */ }
       }
     });
 

package/src/server/responses-custom-tool-repair.ts

@@ -1,8 +1,10 @@
 import type { TranslatorBudget } from "../lib/translator-budget";
 import { normalizeApplyPatchDelimiters } from "../responses/apply-patch-envelope";
+import { compileCodeModeHelperInput } from "../responses/code-mode-helper-compat";
 import {
   customToolItemId,
   restoreRoutedCustomCalls,
+  routedCustomToolTargetName,
   routedCustomToolWireName,
   unwrapRoutedCustomToolArguments,
 } from "../responses/custom-tool-compat";
@@ -87,8 +89,10 @@ export function createRoutedCustomToolRestoreBlockRewrite(
   names: ReadonlySet<string>,
   budget?: TranslatorBudget,
   repairNames: ReadonlySet<string> = new Set(),
+  declaredNames?: ReadonlySet<string>,
 ): SseBlockRewrite {
-  const itemNames = new Map<string, { name: string; namespace?: string }>();
+  const itemNames = new Map<string, { name: string; aliased: boolean; namespace?: string }>();
+  const customAliasItemNames = new Map<string, string>();
   const repairItemNames = new Map<string, string>();
   const ordinaryItemIds = new Set<string>();
   const openCalls = new Map<string, OpenCustomCall>();
@@ -114,6 +118,7 @@ export function createRoutedCustomToolRestoreBlockRewrite(
     }
     pendingArguments = [];
     itemNames.clear();
+    customAliasItemNames.clear();
     repairItemNames.clear();
     ordinaryItemIds.clear();
   };
@@ -187,11 +192,20 @@ export function createRoutedCustomToolRestoreBlockRewrite(
     ) {
       const upstreamItemId = typeof parsed.item.id === "string" ? parsed.item.id : undefined;
       const wireName = routedCustomToolWireName(parsed.item);
+      const targetName = routedCustomToolTargetName(parsed.item, names, declaredNames);
+      const aliased = targetName !== undefined && targetName !== wireName;
+      if (upstreamItemId && aliased) {
+        customAliasItemNames.set(upstreamItemId, parsed.item.name);
+        if (type === "response.output_item.added") {
+          openCalls.set(upstreamItemId, { argumentsText: "", emittedInput: "", retainedBytes: 0 });
+        }
+      }
       const repairable = wireName !== undefined && repairNames.has(wireName);
       if (upstreamItemId && repairable) repairItemNames.set(upstreamItemId, parsed.item.name);
-      const restored = repairable
-        ? restoreRoutedCustomCalls(parsed, names, repairNames)
+      const restored = repairable || aliased
+        ? restoreRoutedCustomCalls(parsed, names, repairNames, declaredNames)
         : { value: parsed, changed: false };
+      if (type === "response.output_item.done" && upstreamItemId) releaseCall(upstreamItemId);
       return restored.changed
         ? [replaceSseDataPayload(block, JSON.stringify(restored.value))]
         : [block];
@@ -203,12 +217,14 @@ export function createRoutedCustomToolRestoreBlockRewrite(
       && typeof parsed.item.name === "string"
     ) {
       const upstreamItemId = typeof parsed.item.id === "string" ? parsed.item.id : undefined;
+      const targetName = routedCustomToolTargetName(parsed.item, names, declaredNames);
+      const routed = targetName !== undefined;
       const wireName = routedCustomToolWireName(parsed.item);
-      const routed = wireName !== undefined && names.has(wireName);
       if (upstreamItemId) {
         if (routed) {
           itemNames.set(upstreamItemId, {
             name: parsed.item.name,
+            aliased: targetName !== wireName,
             ...(typeof parsed.item.namespace === "string" ? { namespace: parsed.item.namespace } : {}),
           });
           ordinaryItemIds.delete(upstreamItemId);
@@ -227,7 +243,7 @@ export function createRoutedCustomToolRestoreBlockRewrite(
       if (upstreamItemId && pending.length > 0 && !openCalls.has(upstreamItemId)) {
         openCalls.set(upstreamItemId, { argumentsText: "", emittedInput: "", retainedBytes: 0 });
       }
-      const restored = restoreRoutedCustomCalls(parsed, names, repairNames);
+      const restored = restoreRoutedCustomCalls(parsed, names, repairNames, declaredNames);
       const restoredBlock = restored.changed
         ? replaceSseDataPayload(block, JSON.stringify(restored.value))
         : block;
@@ -239,6 +255,33 @@ export function createRoutedCustomToolRestoreBlockRewrite(
     }
 
     const upstreamItemId = typeof parsed.item_id === "string" ? parsed.item_id : undefined;
+    if (
+      type === "response.custom_tool_call_input.delta"
+      && upstreamItemId
+      && customAliasItemNames.has(upstreamItemId)
+    ) {
+      const open = openCalls.get(upstreamItemId) ?? { argumentsText: "", emittedInput: "", retainedBytes: 0 };
+      const delta = typeof parsed.delta === "string" ? parsed.delta : "";
+      const deltaBytes = Buffer.byteLength(delta, "utf8");
+      if (deltaBytes > 0) budget?.chargeRetained(deltaBytes, { kind: "retained_collectors" });
+      open.argumentsText += delta;
+      open.retainedBytes += deltaBytes;
+      openCalls.set(upstreamItemId, open);
+      return [];
+    }
+    if (
+      type === "response.custom_tool_call_input.done"
+      && upstreamItemId
+      && customAliasItemNames.has(upstreamItemId)
+    ) {
+      const source = typeof parsed.input === "string"
+        ? parsed.input
+        : openCalls.get(upstreamItemId)?.argumentsText ?? "";
+      return [replaceSseDataPayload(block, JSON.stringify({
+        ...parsed,
+        input: compileCodeModeHelperInput(source, customAliasItemNames.get(upstreamItemId)!),
+      }))];
+    }
     if (
       type === "response.custom_tool_call_input.done"
       && upstreamItemId
@@ -301,12 +344,14 @@ export function createRoutedCustomToolRestoreBlockRewrite(
         ...rest,
         type: nextType,
         item_id: customToolItemId(upstreamItemId),
-        input: unwrapRoutedCustomToolArguments(source, itemName?.name ?? "", itemName?.namespace),
+        input: itemName?.aliased
+          ? compileCodeModeHelperInput(source, itemName.name)
+          : unwrapRoutedCustomToolArguments(source, itemName?.name ?? "", itemName?.namespace),
       };
       return [replaceSseDataPayload(replaceSseEventName(block, nextType), JSON.stringify(next))];
     }
 
-    const restored = restoreRoutedCustomCalls(parsed, names, repairNames);
+    const restored = restoreRoutedCustomCalls(parsed, names, repairNames, declaredNames);
     const terminal = type === "response.completed" || type === "response.failed" || type === "response.incomplete";
     if (terminal) releaseAll();
     return restored.changed

package/src/server/responses-terminal-repair.ts

@@ -22,6 +22,22 @@ function isPlainRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+function isUnframedTerminalLikeSuffix(block: string): boolean {
+  const payload = sseDataPayload(block);
+  if (payload === "[DONE]") return true;
+  if (!payload) return false;
+  try {
+    const parsed = JSON.parse(payload);
+    if (!isPlainRecord(parsed)) return false;
+    return parsed.type === "response.completed"
+      || parsed.type === "response.failed"
+      || parsed.type === "response.incomplete"
+      || parsed.type === "error";
+  } catch {
+    return false;
+  }
+}
+
 function outputIndex(value: unknown): number | null {
   return Number.isInteger(value) && (value as number) >= 0 ? value as number : null;
 }
@@ -292,11 +308,16 @@ export function relayResponsesSseWithTerminalRepair(
         if (done) {
           appendBuffer(decoder.decode());
           if (buffer.length > 0) {
-            // A delimiter-less suffix is not a complete SSE event. Preserve the
-            // upstream bytes for passthrough compatibility, but never let a
-            // truncated lifecycle frame establish synthetic success.
+            // A delimiter-less suffix is not a complete SSE event. Preserve an
+            // ordinary suffix for passthrough compatibility, but never promote
+            // a terminal-like suffix by adding the delimiter it did not receive
+            // upstream. The latter must stay tainted and fail closed through the
+            // synthetic incomplete terminal below.
             tainted = true;
-            controller.enqueue(encoder.encode(buffer));
+            if (!isUnframedTerminalLikeSuffix(buffer)) {
+              controller.enqueue(encoder.encode(buffer));
+              controller.enqueue(encoder.encode(buffer.includes("\r\n") ? "\r\n\r\n" : "\n\n"));
+            }
           }
           if (!realTerminalSeen) {
             emitSynthetic(completeCandidate() ? "completed" : "incomplete", controller);