@iislee/opencodex 2.11.0 → 2.35.0

package/src/server/relay.ts

@@ -1,4 +1,12 @@
 import type { ResponsesTerminalStatus } from "../bridge";
+import {
+  cyberPolicyErrorType,
+  CYBER_POLICY_ERROR_CODE,
+  CYBER_POLICY_FALLBACK_MESSAGE,
+  isCyberPolicyCode,
+  isCyberPolicyMessage,
+} from "../lib/errors";
+import { redactSecretString } from "../lib/redact";
 import { isTranslatorBudgetExceededError } from "../lib/translator-budget";
 import { isUsageDebugEnabled } from "../usage/debug";
 import {
@@ -6,20 +14,49 @@ import {
   addFinalRequestLog,
   httpStatusForRequestLogTerminal,
   inspectResponseLogJson,
-  inspectResponseLogSsePayload,
   inspectResponseLogSsePayloadParsed,
   recordFirstOutput,
   type RequestLogContext,
   type RequestLogEntry,
 } from "./request-log";
+import {
+  BoundedSseFrameBuffer,
+  joinSseFrameBytes,
+  MAX_CLIENT_SSE_FRAME_BYTES,
+} from "./sse-frame-buffer";
+import { replaceSseDataPayload } from "./sse-payload-rewrite";
 
 const nativePassthroughSseResponses = new WeakSet<Response>();
 const eagerRelaySseResponses = new WeakSet<Response>();
 
-export const MAX_INSPECTION_SSE_FRAME_BYTES = 4 * 1024 * 1024;
+export const MAX_INSPECTION_SSE_FRAME_BYTES = MAX_CLIENT_SSE_FRAME_BYTES;
 export const MAX_COMPLETED_OUTPUT_ITEMS = 256;
 export const MAX_COMPLETED_OUTPUT_ITEM_SOURCE_BYTES = 8 * 1024 * 1024;
 export const MAX_TAIL_ERROR_MESSAGE_CHARS = 512;
+const ADAPTER_EOF_INCOMPLETE_PAYLOAD = JSON.stringify({
+  type: "response.incomplete",
+  response: {
+    status: "incomplete",
+    incomplete_details: { reason: "adapter_eof" },
+  },
+});
+const DONE_SSE_FRAME_TEXT = "data: [DONE]\n\n";
+const FAILED_TAIL_FALLBACK_PAYLOAD = JSON.stringify({
+  type: "response.failed",
+  response: {
+    status: "failed",
+    error: {
+      type: "upstream_error",
+      code: "upstream_reset",
+      message: "Upstream stream terminated unexpectedly",
+    },
+    last_error: {
+      type: "upstream_error",
+      code: "upstream_reset",
+      message: "Upstream stream terminated unexpectedly",
+    },
+  },
+});
 
 export type InspectionCounters = {
   frameBufferHighWaterBytes: number;
@@ -95,6 +132,122 @@ export function buildFailedTailPayload(err: unknown): string {
   });
 }
 
+function buildFailedTailPayloadOrFallback(err: unknown): string {
+  try {
+    return buildFailedTailPayload(err);
+  } catch {
+    // Error.message and String(error) may execute hostile accessors. Preserve a
+    // bounded protocol terminal even when diagnostic serialization is unsafe.
+    return FAILED_TAIL_FALLBACK_PAYLOAD;
+  }
+}
+
+export function failedTailFrame(encoder: TextEncoder, err: unknown): Uint8Array {
+  const payload = buildFailedTailPayloadOrFallback(err);
+  return encoder.encode(`\n\nevent: response.failed\ndata: ${payload}\n\n${DONE_SSE_FRAME_TEXT}`);
+}
+
+export type SseTerminalOutputBoundary = {
+  feed(chunk: Uint8Array): Uint8Array;
+  finish(): Uint8Array;
+  terminalSeen(): boolean;
+  doneSeen(): boolean;
+  dispose(): void;
+};
+
+/**
+ * Frame-aware client output boundary shared by both native Responses relays.
+ * It buffers only the current incomplete SSE block under the same hard byte
+ * cap as inspection, forwards complete blocks through the first Responses
+ * terminal, and drops every later block/byte. A premature [DONE] is held until
+ * a terminal arrives so clean EOF can synthesize one terminal and one sentinel.
+ */
+export function createSseTerminalOutputBoundary(): SseTerminalOutputBoundary {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  const framer = new BoundedSseFrameBuffer(MAX_INSPECTION_SSE_FRAME_BYTES);
+  let terminal = false;
+  let done = false;
+  let pendingDone: { block: Uint8Array; delimiter: Uint8Array } | null = null;
+  let disposed = false;
+
+  const processFrames = (
+    frames: ReturnType<BoundedSseFrameBuffer["feed"]>,
+  ): Uint8Array => {
+    if (disposed || terminal || frames.length === 0) return new Uint8Array(0);
+    const output: Uint8Array[] = [];
+    let responsesTerminal = false;
+    for (const frame of frames) {
+      const payload = sseDataPayload(decoder.decode(frame.block));
+      const isDone = payload === "[DONE]";
+      const parsed = payload === null ? undefined : parseSsePayload(payload);
+      const policyError = parsed !== undefined && isPolicyRewriteType(parsed)
+        ? cyberPolicyTerminalError(parsed)
+        : undefined;
+      const outboundBlock = policyError
+        ? encoder.encode(rewritePolicyTerminalBlock(
+          decoder.decode(frame.block),
+          policyFailurePayload(policyError, parsed),
+        ))
+        : frame.block;
+      if (isDone) {
+        done = true;
+        if (responsesTerminal) {
+          output.push(outboundBlock, frame.delimiter);
+        } else if (!pendingDone) {
+          // Do not expose a sentinel before a Responses terminal. If EOF
+          // follows, the synthetic incomplete path owns the one sentinel;
+          // if a terminal arrives later, this pending frame is emitted then.
+          pendingDone = { block: outboundBlock, delimiter: frame.delimiter };
+        }
+        continue;
+      }
+      // Preserve every frame through the first Responses terminal. Every
+      // later non-DONE frame is dropped.
+      if (!responsesTerminal) output.push(outboundBlock, frame.delimiter);
+      if (!responsesTerminal && payload && terminalStatusFromParsed(parsed)) {
+        responsesTerminal = true;
+        if (pendingDone) {
+          output.push(pendingDone.block, pendingDone.delimiter);
+          pendingDone = null;
+        }
+      }
+    }
+    if (responsesTerminal) {
+      terminal = true;
+      framer.dispose();
+    }
+    return joinSseFrameBytes(output);
+  };
+
+  return {
+    feed(chunk) {
+      if (disposed || terminal) return new Uint8Array(0);
+      return processFrames(framer.feed(chunk));
+    },
+    finish() {
+      if (disposed || terminal) return new Uint8Array(0);
+      const tail = framer.finish();
+      if (tail.byteLength === 0) return new Uint8Array(0);
+      // EOF may cut off the final SSE block before its blank-line delimiter.
+      // Feed it through the exact same parser/rewrite/terminal path as a
+      // complete frame, using a synthetic delimiter so the client receives a
+      // dispatchable event rather than an unterminated tail.
+      const tailText = decoder.decode(tail);
+      const delimiter = encoder.encode(tailText.includes("\r\n") ? "\r\n\r\n" : "\n\n");
+      return processFrames([{ block: tail, delimiter }]);
+    },
+    terminalSeen: () => terminal,
+    doneSeen: () => done,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      pendingDone = null;
+      framer.dispose();
+    },
+  };
+}
+
 /**
  * Relay a passthrough SSE body like relayWithAbort, but convert a MID-STREAM failure (upstream
  * reset after headers) into a clean terminal: any partial block is closed off, then a synthetic
@@ -110,26 +263,88 @@ export function relaySseWithFailedTail(
 ): ReadableStream<Uint8Array> {
   const reader = body.getReader();
   const encoder = new TextEncoder();
+  const terminalBoundary = createSseTerminalOutputBoundary();
+  let closed = false;
+  const relayChunk = (
+    controller: ReadableStreamDefaultController<Uint8Array>,
+    value: Uint8Array,
+  ): "terminal" | "output" | "buffered" => {
+    const outbound = terminalBoundary.feed(value);
+    if (outbound.byteLength > 0) controller.enqueue(outbound);
+    if (!terminalBoundary.terminalSeen()) return outbound.byteLength > 0 ? "output" : "buffered";
+
+    // A Responses terminal frame is the protocol boundary. Some compatible
+    // gateways leave the HTTP connection open after response.completed, which
+    // otherwise leaves Codex waiting forever even though the model turn is done.
+    // Preserve through the terminal block only, add the conventional sentinel
+    // when there was no real [DONE] data event, then stop reading upstream.
+    if (!terminalBoundary.doneSeen()) {
+      controller.enqueue(doneFrame(encoder));
+    }
+    closed = true;
+    controller.close();
+    const reason = "Responses terminal event received";
+    // Notify the tee inspection branch as well. It has already received the
+    // same terminal-bearing upstream chunk, so its bounded drain records the
+    // real terminal and then releases the turn/upstream keep-alive connection.
+    onClientGone?.(reason);
+    reader.cancel(reason).catch(() => {});
+    terminalBoundary.dispose();
+    return "terminal";
+  };
   return new ReadableStream<Uint8Array>({
     async pull(controller) {
       try {
-        const { done, value } = await reader.read();
-        if (done) {
-          controller.close();
-          return;
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) {
+            const tail = terminalBoundary.finish();
+            if (tail.byteLength > 0) controller.enqueue(tail);
+            if (terminalBoundary.terminalSeen()) {
+              if (!terminalBoundary.doneSeen()) controller.enqueue(doneFrame(encoder));
+            } else {
+              // A clean upstream EOF is still a failed Responses turn when no
+              // protocol terminal arrived. Make that state explicit so Codex
+              // does not treat HTTP 200 + bare EOF as a retryable disconnect.
+              const incomplete = adapterEofIncompleteFrame(encoder);
+              controller.enqueue(incomplete);
+              controller.enqueue(doneFrame(encoder));
+            }
+            terminalBoundary.dispose();
+            controller.close();
+            return;
+          }
+          const result = relayChunk(controller, value);
+          if (result !== "buffered") return;
         }
-        controller.enqueue(value);
       } catch (err) {
-        const payload = buildFailedTailPayload(err);
+        let partial: Uint8Array = new Uint8Array(0);
+        let tailTerminal = false;
+        try {
+          partial = terminalBoundary.finish();
+          tailTerminal = terminalBoundary.terminalSeen();
+        } catch {
+          // A near-cap ambiguous delimiter tail may itself overflow at EOF.
+          // Preserve the original read/framing failure and continue emitting
+          // the bounded failed tail instead of letting cleanup throw again.
+        }
+        terminalBoundary.dispose();
+        if (closed) return;
         try {
-          // Leading blank line terminates a partial SSE block so the failed frame parses cleanly.
-          controller.enqueue(encoder.encode(`\n\nevent: response.failed\ndata: ${payload}\n\ndata: [DONE]\n\n`));
+          if (partial.byteLength > 0) controller.enqueue(partial);
+          if (tailTerminal) {
+            if (!terminalBoundary.doneSeen()) controller.enqueue(doneFrame(encoder));
+          } else {
+            // Leading blank line terminates a partial SSE block so the failed frame parses cleanly.
+            controller.enqueue(failedTailFrame(encoder, err));
+          }
           controller.close();
         } catch { /* client already torn down */ }
         upstream.abort();
       }
     },
     cancel(reason) {
+      terminalBoundary.dispose();
       if (onClientGone) onClientGone(reason);
       else upstream.abort(reason);
       reader.cancel(reason).catch(() => {});
@@ -137,11 +352,12 @@ export function relaySseWithFailedTail(
   });
 }
 
-export function nextSseBlock(buffer: string): { block: string; rest: string } | null {
+export function nextSseBlock(buffer: string): { block: string; delimiter: string; rest: string } | null {
   const match = buffer.match(/\r?\n\r?\n/);
   if (!match || match.index === undefined) return null;
   return {
     block: buffer.slice(0, match.index),
+    delimiter: match[0],
     rest: buffer.slice(match.index + match[0].length),
   };
 }
@@ -156,15 +372,139 @@ export function sseDataPayload(block: string): string | null {
   return data.length > 0 ? data.join("\n") : null;
 }
 
-export function terminalStatusFromSsePayload(payload: string): ResponsesTerminalStatus | null {
-  if (payload === "[DONE]") return null;
+type JsonRecord = Record<string, unknown>;
+
+function asJsonRecord(value: unknown): JsonRecord | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value as JsonRecord
+    : null;
+}
+
+function stringField(record: JsonRecord | null, key: string): string | undefined {
+  const value = record?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+/**
+ * Return a high-confidence policy error carried by an upstream terminal shape.
+ * Deliberately inspect structured error fields and known refusal copy only — a
+ * bare `cyber_policy` token in an unrelated payload is not sufficient.
+ */
+function cyberPolicyTerminalError(parsed: unknown): { message: string; type?: string } | undefined {
+  const root = asJsonRecord(parsed);
+  if (!root) return undefined;
+  const response = asJsonRecord(root.response);
+  const candidates = [
+    asJsonRecord(root.error),
+    asJsonRecord(root.last_error),
+    asJsonRecord(response?.error),
+    asJsonRecord(response?.incomplete_details),
+    root,
+    response,
+  ];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    if (isCyberPolicyCode(stringField(candidate, "code"))) {
+      return {
+        message: stringField(candidate, "message")
+          ?? CYBER_POLICY_FALLBACK_MESSAGE,
+        ...(stringField(candidate, "type") ? { type: stringField(candidate, "type") } : {}),
+      };
+    }
+  }
+  for (const candidate of candidates) {
+    const message = stringField(candidate, "message");
+    if (message && isCyberPolicyMessage(message)) {
+      return {
+        message,
+        ...(stringField(candidate, "type") ? { type: stringField(candidate, "type") } : {}),
+      };
+    }
+  }
+  return undefined;
+}
+
+function parseSsePayload(payload: string): unknown | undefined {
+  if (payload === "[DONE]") return undefined;
   try {
-    return terminalStatusFromParsed(JSON.parse(payload));
+    return JSON.parse(payload);
   } catch {
-    return null;
+    return undefined;
   }
 }
 
+function isPolicyRewriteType(parsed: unknown): boolean {
+  const type = asJsonRecord(parsed)?.type;
+  return type === "response.failed" || type === "response.incomplete" || type === "error";
+}
+
+function rewritePolicyTerminalBlock(block: string, payload: string): string {
+  const newline = block.includes("\r\n") ? "\r\n" : "\n";
+  const rewritten = replaceSseDataPayload(block, payload);
+  const lines = rewritten.split(/\r?\n/);
+  let eventRewritten = false;
+  const withEvent = lines.map(line => {
+    if (!eventRewritten && line.startsWith("event:")) {
+      eventRewritten = true;
+      return "event: response.failed";
+    }
+    return line;
+  });
+  if (!eventRewritten) withEvent.unshift("event: response.failed");
+  return withEvent.join(newline);
+}
+
+function policyFailurePayload(policyError: { message: string; type?: string }, parsed: unknown): string {
+  const error = {
+    type: cyberPolicyErrorType(policyError.type),
+    code: CYBER_POLICY_ERROR_CODE,
+    message: redactSecretString(policyError.message).slice(0, MAX_TAIL_ERROR_MESSAGE_CHARS),
+  };
+  const root = asJsonRecord(parsed);
+  const originalResponse = asJsonRecord(root?.response);
+  const preservedResponse = Object.fromEntries(
+    Object.entries(originalResponse ?? {}).filter(([key]) => key !== "incomplete_details"),
+  );
+  const response = {
+    ...preservedResponse,
+    status: "failed",
+    error,
+    last_error: error,
+    retryable: false,
+  };
+  // Responses event metadata such as sequence_number is normally top-level.
+  // Keep it (and any other non-error, non-response fields) while replacing only
+  // the protocol type and error envelope.
+  const preservedRoot = root
+    ? Object.fromEntries(Object.entries(root).filter(([key]) => (
+      key !== "type"
+      && key !== "response"
+      && key !== "error"
+      && key !== "last_error"
+      && key !== "retryable"
+    )))
+    : {};
+  return JSON.stringify({
+    ...preservedRoot,
+    type: "response.failed",
+    retryable: false,
+    response,
+  });
+}
+
+export function adapterEofIncompleteFrame(encoder: TextEncoder): Uint8Array {
+  return encoder.encode(`event: response.incomplete\ndata: ${ADAPTER_EOF_INCOMPLETE_PAYLOAD}\n\n`);
+}
+
+export function doneFrame(encoder: TextEncoder): Uint8Array {
+  return encoder.encode(DONE_SSE_FRAME_TEXT);
+}
+
+export function terminalStatusFromSsePayload(payload: string): ResponsesTerminalStatus | null {
+  if (payload === "[DONE]") return null;
+  return terminalStatusFromParsed(parseSsePayload(payload));
+}
+
 /** True when a native Responses SSE payload carries the FIRST kind of non-empty model output. */
 export function isFirstOutputSsePayload(payload: string | null): boolean {
   if (!payload || payload === "[DONE]") return false;
@@ -202,14 +542,16 @@ function createFirstOutputReporter(onFirstOutput?: () => void): {
 }
 
 export function terminalStatusFromParsed(parsed: unknown): ResponsesTerminalStatus | null {
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
-  switch ((parsed as { type?: unknown }).type) {
+  const type = asJsonRecord(parsed)?.type;
+  switch (type) {
     case "response.completed":
       return "completed";
     case "response.failed":
       return "failed";
     case "response.incomplete":
-      return "incomplete";
+      return cyberPolicyTerminalError(parsed) ? "failed" : "incomplete";
+    case "error":
+      return cyberPolicyTerminalError(parsed) ? "failed" : null;
     default:
       return null;
   }
@@ -245,53 +587,52 @@ export function trackSseForRequestLog(
   onFirstOutput?: () => void,
 ): ReadableStream<Uint8Array> {
   const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
   let terminalReported = false;
-  const reportFirstOutput = createFirstOutputReporter(onFirstOutput);
+  let cancelled = false;
 
   const reportTerminal = (status: ResponsesTerminalStatus) => {
     if (terminalReported) return;
     terminalReported = true;
     onTerminal(status);
   };
-
-  const inspectPayload = (payload: string | null) => {
-    if (!payload) return;
-    if (logCtx) inspectResponseLogSsePayload(logCtx, payload);
-    reportFirstOutput.payload(payload);
-    const status = terminalStatusFromSsePayload(payload);
-    if (status) reportTerminal(status);
-  };
-
-  const inspectChunk = (value: Uint8Array) => {
-    buffer += decoder.decode(value, { stream: true });
-    let next: { block: string; rest: string } | null;
-    while ((next = nextSseBlock(buffer))) {
-      buffer = next.rest;
-      inspectPayload(sseDataPayload(next.block));
-    }
-  };
+  // Reuse the byte-bounded inspector so translated responses cannot retain an
+  // unterminated upstream frame or parse the same event once per observer.
+  const inspector = createSseInspector({
+    onTerminal: reportTerminal,
+    logCtx,
+    onFirstOutput,
+  });
 
   return new ReadableStream<Uint8Array>({
     async pull(controller) {
       try {
         const { done, value } = await reader.read();
         if (done) {
-          buffer += decoder.decode();
-          if (buffer.trim()) inspectPayload(sseDataPayload(buffer));
-          if (!terminalReported) reportTerminal("incomplete");
+          if (!cancelled) {
+            inspector.finish();
+            if (!terminalReported) reportTerminal("incomplete");
+          }
+          inspector.dispose();
           controller.close();
           return;
         }
-        inspectChunk(value);
+        inspector.feed(value);
         controller.enqueue(value);
       } catch (err) {
-        if (!terminalReported) reportTerminal("incomplete");
+        // The upstream read rejected: the 200 body died mid-flight. Client
+        // cancellation is the caller's separate 499 path, so a cancel-drained
+        // pending read (cancelled=true) must not carry the truncation marker.
+        if (!cancelled && !terminalReported && logCtx?.activeAttempt) {
+          logCtx.activeAttempt.streamAborted = true;
+        }
+        if (!cancelled && !terminalReported) reportTerminal("incomplete");
+        inspector.dispose();
         try { controller.error(err); } catch { /* already torn down */ }
       }
     },
     cancel(reason) {
+      cancelled = true;
+      inspector.dispose();
       onCancel();
       reader.cancel(reason).catch(() => {});
     },
@@ -402,38 +743,23 @@ export function relaySseWithHeartbeat(
 ): ReadableStream<Uint8Array> | null {
   if (!body) return null;
   const reader = body.getReader();
-  const decoder = new TextDecoder();
   const heartbeat = new TextEncoder().encode(": opencodex keepalive\n\n");
   let timer: ReturnType<typeof setInterval> | undefined;
   let closed = false;
   let clientCancelled = false;
   let terminalReported = false;
-  let buffer = "";
 
   const reportTerminal = (status: ResponsesTerminalStatus) => {
     if (terminalReported || clientCancelled || closed) return;
     terminalReported = true;
     onTerminal?.(status);
   };
-
-  const inspectPayload = (payload: string | null) => {
-    if (!payload) return;
-    const status = terminalStatusFromSsePayload(payload);
-    if (status) reportTerminal(status);
-  };
-
-  const inspectChunk = (value: Uint8Array) => {
-    buffer += decoder.decode(value, { stream: true });
-    let next: { block: string; rest: string } | null;
-    while ((next = nextSseBlock(buffer))) {
-      buffer = next.rest;
-      inspectPayload(sseDataPayload(next.block));
-    }
-  };
+  const inspector = createSseInspector({ onTerminal: reportTerminal });
 
   const cleanup = () => {
     if (closed) return;
     closed = true;
+    inspector.dispose();
     if (timer) clearInterval(timer);
     timer = undefined;
     options?.onDone?.();
@@ -455,14 +781,13 @@ export function relaySseWithHeartbeat(
       try {
         const { done, value } = await reader.read();
         if (done) {
-          buffer += decoder.decode();
-          if (buffer.trim()) inspectPayload(sseDataPayload(buffer));
+          inspector.finish();
           if (!terminalReported && !clientCancelled) reportTerminal("incomplete");
           cleanup();
           controller.close();
           return;
         }
-        inspectChunk(value);
+        inspector.feed(value);
         controller.enqueue(value);
       } catch (err) {
         if (!clientCancelled) reportTerminal("incomplete");
@@ -500,7 +825,20 @@ export type SseInspectorHandlers = {
   onTerminal?: (status: ResponsesTerminalStatus, httpStatusOverride?: number) => void;
   logCtx?: RequestLogContext;
   onCompletedResponse?: (response: { id?: unknown; output?: unknown; status?: unknown }) => void;
+  /**
+   * Every parsed SSE payload, delivered BEFORE any onCompletedResponse derived from that same
+   * payload. A caller that must decide on the whole turn -- not just its terminal snapshot --
+   * needs to see the incremental events, because a stream can announce an item and then close
+   * with an empty `output`.
+   */
+  onParsedPayload?: (payload: unknown) => void;
   onFirstOutput?: () => void;
+  /**
+   * Provider-scoped compatibility: persist the completed snapshot under the
+   * first response id exposed to the client when an upstream changes ids
+   * between `response.created` and `response.completed`.
+   */
+  pinCompletedResponseIdToFirstSeen?: boolean;
 };
 
 type CompletedOutputItem = { item: unknown; sourceBytes: number };
@@ -530,17 +868,6 @@ function delimiterLengthAt(
   return byteAt(index + 3) === 10 ? 4 : 0;
 }
 
-function joinedBytes(slices: readonly Uint8Array[], byteLength: number): Uint8Array {
-  if (slices.length === 1 && slices[0]!.byteLength === byteLength) return slices[0]!;
-  const joined = new Uint8Array(byteLength);
-  let offset = 0;
-  for (const slice of slices) {
-    joined.set(slice, offset);
-    offset += slice.byteLength;
-  }
-  return joined;
-}
-
 /**
  * Per-chunk SSE inspection state machine shared by consumeForInspection,
  * consumeForResponseLogMetadata, and the eager bounded relay (relay-eager.ts).
@@ -561,8 +888,8 @@ export function createSseInspector(handlers: SseInspectorHandlers): SseInspector
   let reported = false;
   let sawTerminal = false;
   let disposed = false;
-  let delimiterTail = new Uint8Array(0);
-  let candidateSlices: Uint8Array[] = [];
+  let delimiterTail: Uint8Array = new Uint8Array(0);
+  let candidate: Uint8Array = new Uint8Array(0);
   let candidateBytes = 0;
   let discardingOversizedFrame = false;
   const reportFirstOutput = createFirstOutputReporter(handlers.onFirstOutput);
@@ -572,10 +899,11 @@ export function createSseInspector(handlers: SseInspectorHandlers): SseInspector
     : null;
   let aggregateItemBytes = 0;
   let reconstructionTainted = false;
+  let firstResponseId: string | undefined;
 
   const clearFrameState = (): void => {
     delimiterTail = new Uint8Array(0);
-    candidateSlices = [];
+    candidate = new Uint8Array(0);
     candidateBytes = 0;
     discardingOversizedFrame = false;
   };
@@ -592,6 +920,31 @@ export function createSseInspector(handlers: SseInspectorHandlers): SseInspector
     decoder = null;
     clearFrameState();
     clearCompletedItems();
+    firstResponseId = undefined;
+  };
+
+  const ensureCandidateCapacity = (requiredBytes: number): void => {
+    if (candidate.byteLength >= requiredBytes) return;
+    let capacity = candidate.byteLength === 0
+      ? Math.min(MAX_INSPECTION_SSE_FRAME_BYTES, Math.max(requiredBytes, 4096))
+      : candidate.byteLength;
+    while (capacity < requiredBytes) {
+      capacity = Math.min(
+        MAX_INSPECTION_SSE_FRAME_BYTES,
+        Math.max(requiredBytes, capacity * 2),
+      );
+    }
+    const grown = new Uint8Array(capacity);
+    if (candidateBytes > 0) grown.set(candidate.subarray(0, candidateBytes));
+    candidate = grown;
+  };
+
+  const takeCandidate = (): Uint8Array => {
+    if (candidateBytes === 0) return new Uint8Array(0);
+    const frame = candidate.slice(0, candidateBytes);
+    candidate = new Uint8Array(0);
+    candidateBytes = 0;
+    return frame;
   };
 
   const retainCandidateSlice = (slice: Uint8Array): void => {
@@ -602,7 +955,7 @@ export function createSseInspector(handlers: SseInspectorHandlers): SseInspector
       Math.min(nextBytes, MAX_INSPECTION_SSE_FRAME_BYTES),
     );
     if (nextBytes > MAX_INSPECTION_SSE_FRAME_BYTES) {
-      candidateSlices = [];
+      candidate = new Uint8Array(0);
       candidateBytes = 0;
       discardingOversizedFrame = true;
       inspectionCounters.frameCapOverflows += 1;
@@ -612,10 +965,8 @@ export function createSseInspector(handlers: SseInspectorHandlers): SseInspector
       reconstructionTainted = true;
       return;
     }
-    // `subarray()` aliases the upstream chunk's backing buffer. Copy only the
-    // live candidate bytes so a tiny trailing frame cannot pin a multi-MiB
-    // chunk whose preceding frames have already been consumed.
-    candidateSlices.push(slice.slice());
+    ensureCandidateCapacity(nextBytes);
+    candidate.set(slice, candidateBytes);
     candidateBytes = nextBytes;
   };
 
@@ -664,8 +1015,16 @@ export function createSseInspector(handlers: SseInspectorHandlers): SseInspector
     if (!reported && handlers.logCtx) {
       inspectResponseLogSsePayloadParsed(handlers.logCtx, payload, parsed);
     }
+    // Before any terminal handling: a consumer deciding on the whole turn must observe this
+    // payload even when the terminal snapshot that follows no longer mentions it.
+    if (handlers.onParsedPayload && parsed !== undefined) {
+      try { handlers.onParsedPayload(parsed); } catch { /* inspection must never throw into the pump */ }
+    }
     reportFirstOutput.parsed(parsed);
     const status = terminalStatusFromParsed(parsed);
+    const policyTerminal = status === "failed"
+      && isPolicyRewriteType(parsed)
+      && cyberPolicyTerminalError(parsed) !== undefined;
     if (status) sawTerminal = true;
     if (!reported && handlers.onTerminal && status) {
       try {
@@ -674,7 +1033,7 @@ export function createSseInspector(handlers: SseInspectorHandlers): SseInspector
           handlers.logCtx.transportPhase = "terminal_sse";
           handlers.logCtx.terminalSource = "upstream";
         }
-        handlers.onTerminal(status);
+        handlers.onTerminal(status, policyTerminal ? 400 : undefined);
       } finally {
         if (status === "failed" || status === "incomplete") clearCompletedItems();
       }
@@ -686,6 +1045,17 @@ export function createSseInspector(handlers: SseInspectorHandlers): SseInspector
       const parsedEvent = parsed && typeof parsed === "object" && !Array.isArray(parsed)
         ? parsed as ParsedSseEvent
         : null;
+      const responseRecord = parsedEvent
+        && typeof parsedEvent.response === "object"
+        && parsedEvent.response !== null
+        && !Array.isArray(parsedEvent.response)
+        ? parsedEvent.response as { id?: unknown }
+        : null;
+      if (handlers.pinCompletedResponseIdToFirstSeen
+        && responseRecord
+        && typeof responseRecord.id === "string") {
+        firstResponseId ??= responseRecord.id;
+      }
       const doneItem = parsedEvent?.type === "response.output_item.done" ? parsedEvent.item : undefined;
       if (parsedEvent
         && doneItem !== undefined
@@ -700,6 +1070,11 @@ export function createSseInspector(handlers: SseInspectorHandlers): SseInspector
 
       let response = completedResponseFromParsedEvent(parsedEvent);
       if (response) {
+        if (handlers.pinCompletedResponseIdToFirstSeen
+          && firstResponseId !== undefined
+          && response.id !== firstResponseId) {
+          response = { ...response, id: firstResponseId };
+        }
         // Authoritative output is a NON-EMPTY ARRAY only. Anything else
         // (missing, null, scalar, object) keeps the historical backfill
         // behavior so a malformed terminal cannot reach rememberResponseState
@@ -735,9 +1110,7 @@ export function createSseInspector(handlers: SseInspectorHandlers): SseInspector
       return;
     }
     const sourceBytes = candidateBytes;
-    const frame = joinedBytes(candidateSlices, sourceBytes);
-    candidateSlices = [];
-    candidateBytes = 0;
+    const frame = takeCandidate();
     if (reported && !handlers.onCompletedResponse) return;
     const decoded = decoder!.decode(frame);
     scanPayload(sseDataPayload(decoded), sourceBytes);
@@ -794,7 +1167,7 @@ export function createSseInspector(handlers: SseInspectorHandlers): SseInspector
         delimiterTail = new Uint8Array(0);
         if (!discardingOversizedFrame && candidateBytes > 0 && !reported) {
           const sourceBytes = candidateBytes;
-          const decoded = decoder!.decode(joinedBytes(candidateSlices, sourceBytes));
+          const decoded = decoder!.decode(takeCandidate());
           scanPayload(decoded.trim() ? sseDataPayload(decoded) : null, sourceBytes);
         }
       } finally {
@@ -815,6 +1188,10 @@ export type InspectionConsumerOptions = {
   drainBounds?: Partial<InspectionDrainBounds>;
   upstream?: AbortController;
   now?: () => number;
+  /** Forward provider-scoped response-id pinning to the owned inspector. */
+  pinCompletedResponseIdToFirstSeen?: boolean;
+  /** Observe every parsed SSE payload on the inspection side; see SseInspectorHandlers. */
+  onParsedPayload?: (payload: unknown) => void;
   /** Test seam for proving both public consumers dispose their owned inspector. */
   inspectorFactory?: (handlers: SseInspectorHandlers) => SseInspector;
 };
@@ -935,6 +1312,13 @@ function startBoundedInspectionPump(options: InspectionPumpOptions): void {
         }
       }
     } catch {
+      // A read error can follow a final SSE block without its blank-line
+      // delimiter. Flush that candidate before classifying the transport as a
+      // synthetic reset; otherwise a real completed/failed/policy terminal is
+      // downgraded to 502 on the inspection branch.
+      if (!cancelled) {
+        try { inspector.finish(); } catch { /* preserve the original read error */ }
+      }
       if (clientGone) clientGoneWithoutTerminal = !inspector.terminalSeen();
       else if (!cancelled) options.onReadError?.();
     } finally {
@@ -970,7 +1354,9 @@ export function consumeForInspection(
     onTerminal,
     logCtx,
     onCompletedResponse,
+    onParsedPayload: options?.onParsedPayload,
     onFirstOutput,
+    pinCompletedResponseIdToFirstSeen: options?.pinCompletedResponseIdToFirstSeen,
   });
   startBoundedInspectionPump({
     ...options,
@@ -993,6 +1379,10 @@ export function consumeForInspection(
         if (logCtx) {
           logCtx.transportPhase = "mid_stream";
           logCtx.terminalSource = "synthetic";
+          // A truncated 200 body must not meter as a success the client never
+          // received; the router's equivalent turn carries 502 + streamAborted
+          // (codex-router #139).
+          if (logCtx.activeAttempt) logCtx.activeAttempt.streamAborted = true;
         }
         onTerminal("failed", 502);
       }
@@ -1015,7 +1405,9 @@ export function consumeForResponseLogMetadata(
   const inspector = (options?.inspectorFactory ?? createSseInspector)({
     logCtx,
     onCompletedResponse,
+    onParsedPayload: options?.onParsedPayload,
     onFirstOutput,
+    pinCompletedResponseIdToFirstSeen: options?.pinCompletedResponseIdToFirstSeen,
   });
   startBoundedInspectionPump({ ...options, reader, inspector, signal, onDone });
 }