@yansigit/opencodex 2.33.1 → 2.35.0

package/src/server/management-api.ts

@@ -70,6 +70,7 @@ import { handleOauthAccountRoutes } from "./management/oauth-account-routes";
 import { handleComboRoutes } from "./management/combo-routes";
 import { handleSystemRoutes } from "./management/system-routes";
 import { handleSidebarRoutes } from "./management/sidebar-routes";
+import { handleCodexPromptRoutes } from "./management/codex-prompt-routes";
 import { handleIntegrationRoutes } from "./management/integration-routes";
 import { handleNativeIntegrationRoutes } from "./management/native-integration-routes";
 import type { ManagementContext } from "./management/context";
@@ -229,6 +230,7 @@ export async function handleManagementAPI(
     ??     (await handleIntegrationRoutes(ctx))
     ??     (await handleNativeIntegrationRoutes(ctx))
     ??     (await handleAgentSettingsRoutes(ctx))
+    ??     (await handleCodexPromptRoutes(ctx))
     ??     (await handleOauthAccountRoutes(ctx))
     ??     (await handleComboRoutes(ctx))
     ??     (await handleSystemRoutes(ctx))

package/src/server/relay-eager.ts

@@ -24,7 +24,12 @@
  * up to the drain window.
  */
 
-import { buildFailedTailPayload, createSseTerminalOutputBoundary } from "./relay";
+import {
+  adapterEofIncompleteFrame,
+  createSseTerminalOutputBoundary,
+  doneFrame,
+  failedTailFrame,
+} from "./relay";
 import {
   nextSseBlock,
   payloadRewriteAsBlockRewrite,
@@ -100,9 +105,19 @@ export function relaySseEagerBounded(
   const now = opts?.now ?? Date.now;
 
   const reader = body.getReader();
+  const terminalEncoder = new TextEncoder();
+  const adapterEofFrame = adapterEofIncompleteFrame(terminalEncoder);
+  const terminalSentinel = doneFrame(terminalEncoder);
   const terminalBoundary = createSseTerminalOutputBoundary();
   const activeRewrite: SseBlockRewrite | undefined = hooks.rewriteBlocks
     ?? (hooks.rewritePayload ? payloadRewriteAsBlockRewrite(hooks.rewritePayload) : undefined);
+  const encodeFailedTail = (error: unknown): Uint8Array | null => {
+    try {
+      return failedTailFrame(terminalEncoder, error);
+    } catch {
+      return null;
+    }
+  };
   const rewriteDecoder = activeRewrite ? new TextDecoder() : null;
   const rewriteEncoder = activeRewrite ? new TextEncoder() : null;
   const rewriteBudget = opts?.rewriteBudget;
@@ -164,13 +179,21 @@ export function relaySseEagerBounded(
   let queuedBytes = 0;
   let cancelled = false;
   let done = false;
-  const terminalSentinel = new TextEncoder().encode("data: [DONE]\n\n");
   // Pause gate: resolved by client pull, client cancel, or upstream abort so a
   // paused producer ALWAYS resumes (audit blocker 2 — no deadlock; onDone and
   // turn unregistration stay reachable, drainAndShutdown never hangs).
   let wake: (() => void) | null = null;
   const wakeUp = () => { const w = wake; wake = null; w?.(); };
-  const paused = () => new Promise<void>(resolve => { wake = resolve; });
+  const paused = () => new Promise<void>(resolve => {
+    wake = resolve;
+    // A pull, cancel, or abort can win the tiny window between the loop's
+    // predicate check and installing this resolver. Re-check every wake
+    // predicate after installation so that an already-fired wake cannot leave
+    // the producer parked forever.
+    if (queuedBytes <= maxQueueBytes || cancelled || upstream.signal.aborted) {
+      wakeUp();
+    }
+  });
   upstream.signal.addEventListener("abort", wakeUp, { once: true });
 
   let controllerRef: ReadableStreamDefaultController<Uint8Array> | null = null;
@@ -196,6 +219,9 @@ export function relaySseEagerBounded(
 
   const producer = async () => {
     let syntheticKind: "incomplete" | "failed" | null = null;
+    let deliveryFallbackSent = false;
+    let priorRewriteFailure = false;
+    let priorRewriteError: unknown;
     // reader.read() is not intrinsically tied to the upstream AbortController
     // (a fetch body usually rejects on abort, but that coupling is the fetch
     // implementation's, not the stream's), so abort must break a parked read on
@@ -221,18 +247,46 @@ export function relaySseEagerBounded(
         if (upstreamDone) {
           hooks.finishInspection();
           const boundedTail = terminalBoundary.finish();
+          let clientTail = boundedTail;
+          let rewriteFailed = false;
+          let rewriteError: unknown;
           if (activeRewrite) {
-            const rewritten = rewriteOutbound(boundedTail);
-            const tail = joinUint8Arrays(rewritten, flushRewriteTail());
-            if (tail.byteLength > 0 && !cancelled) {
-              queuedBytes += tail.byteLength;
-              try { controllerRef?.enqueue(tail); } catch { /* client already gone */ }
+            try {
+              const rewritten = rewriteOutbound(boundedTail);
+              clientTail = joinUint8Arrays(rewritten, flushRewriteTail());
+            } catch (error) {
+              rewriteFailed = true;
+              rewriteError = error;
+              clientTail = new Uint8Array(0);
+            }
+          }
+          if (rewriteFailed) {
+            const safeTail = encodeFailedTail(rewriteError);
+            if (safeTail && !cancelled && !upstream.signal.aborted) {
+              if (!hooks.sawTerminal()) syntheticKind = "failed";
+              queuedBytes += safeTail.byteLength;
+              try { controllerRef?.enqueue(safeTail); } catch { /* client already torn down */ }
+              try { controllerRef?.close(); } catch { /* client already gone */ }
             }
-          } else if (boundedTail.byteLength > 0 && !cancelled) {
-            queuedBytes += boundedTail.byteLength;
-            try { controllerRef?.enqueue(boundedTail); } catch { /* client already gone */ }
+            break;
+          }
+          if (clientTail.byteLength > 0 && !cancelled) {
+            queuedBytes += clientTail.byteLength;
+            try { controllerRef?.enqueue(clientTail); } catch { /* client already gone */ }
           }
-          if (!hooks.sawTerminal() && !cancelled && !upstream.signal.aborted) {
+          if (terminalBoundary.terminalSeen()) {
+            if (!terminalBoundary.doneSeen() && !cancelled) {
+              queuedBytes += terminalSentinel.byteLength;
+              try { controllerRef?.enqueue(terminalSentinel); } catch { /* client already gone */ }
+            }
+          } else if (!hooks.sawTerminal() && !cancelled && !upstream.signal.aborted) {
+            // A clean 200 EOF without a Responses terminal must be visible to
+            // Codex as one incomplete turn, followed by the normal sentinel.
+            queuedBytes += adapterEofFrame.byteLength + terminalSentinel.byteLength;
+            try {
+              controllerRef?.enqueue(adapterEofFrame);
+              controllerRef?.enqueue(terminalSentinel);
+            } catch { /* client already gone */ }
             syntheticKind = "incomplete";
           }
           break;
@@ -247,7 +301,21 @@ export function relaySseEagerBounded(
           continue;
         }
         const terminalBounded = terminalBoundary.feed(value);
-        const outbound = activeRewrite ? rewriteOutbound(terminalBounded) : terminalBounded;
+        let outbound: Uint8Array;
+        if (activeRewrite) {
+          try {
+            outbound = rewriteOutbound(terminalBounded);
+          } catch (error) {
+            // Preserve the first rewrite failure across the teardown flush. A
+            // second empty flush may succeed, but the terminal bytes still
+            // must not bypass the failed rewrite or become DONE-only output.
+            priorRewriteFailure = true;
+            priorRewriteError = error;
+            throw error;
+          }
+        } else {
+          outbound = terminalBounded;
+        }
         if (outbound.byteLength > 0) {
           queuedBytes += outbound.byteLength;
           try {
@@ -278,16 +346,75 @@ export function relaySseEagerBounded(
     } catch (err) {
       // Upstream read failure. Distinguish genuine mid-stream reset from
       // abort-driven teardown (shutdown/cancel-expiry) — audit M3.
-      if (!hooks.sawTerminal() && !cancelled && !upstream.signal.aborted) {
+      // A read can fail after delivering an unterminated terminal block. Flush
+      // both observers before deciding whether this is a synthetic reset so
+      // eager mode matches the tee/pull boundary semantics at EOF.
+      let boundedTail: Uint8Array<ArrayBufferLike> = new Uint8Array(0);
+      let tailTerminal = false;
+      let tailDone = false;
+      try { hooks.finishInspection(); } catch { /* preserve the original read failure */ }
+      try {
+        boundedTail = terminalBoundary.finish();
+        tailTerminal = terminalBoundary.terminalSeen();
+        tailDone = terminalBoundary.doneSeen();
+      } 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.
+      }
+      let clientTail: Uint8Array<ArrayBufferLike> = boundedTail;
+      let rewriteFailed = false;
+      let rewriteError: unknown;
+      if (priorRewriteFailure) {
+        rewriteFailed = true;
+        rewriteError = priorRewriteError;
+        clientTail = new Uint8Array(0);
+      } else if (activeRewrite) {
+        try {
+          const rewritten = rewriteOutbound(boundedTail);
+          clientTail = joinUint8Arrays(rewritten, flushRewriteTail());
+        } catch (error) {
+          rewriteFailed = true;
+          rewriteError = error;
+          clientTail = new Uint8Array(0);
+        }
+      }
+      if (clientTail.byteLength > 0 && !cancelled && !upstream.signal.aborted) {
+        queuedBytes += clientTail.byteLength;
+        try { controllerRef?.enqueue(clientTail); } catch { /* client already torn down */ }
+      }
+      if (rewriteFailed && !cancelled && !upstream.signal.aborted) {
+        // Never bypass a client rewrite after it fails: boundedTail can contain
+        // provider metadata or content that the active rewrite was required to
+        // remove. Emit one safe failed envelope instead. When inspection has
+        // already reported the real upstream terminal, this is a delivery
+        // fallback only and must not create a second accounting outcome.
+        const safeTail = encodeFailedTail(rewriteError ?? err);
+        if (safeTail && !cancelled && !upstream.signal.aborted) {
+          if (!hooks.sawTerminal()) syntheticKind = "failed";
+          deliveryFallbackSent = true;
+          queuedBytes += safeTail.byteLength;
+          try { controllerRef?.enqueue(safeTail); } catch { /* client already torn down */ }
+          try { controllerRef?.close(); } catch { /* client already gone */ }
+        }
+      } else if (tailTerminal && !cancelled && !upstream.signal.aborted) {
+        if (!tailDone) {
+          queuedBytes += terminalSentinel.byteLength;
+          try { controllerRef?.enqueue(terminalSentinel); } catch { /* client already gone */ }
+        }
+      } else if (!tailTerminal && !cancelled && !upstream.signal.aborted) {
         // Serializing `err` can run user-defined accessors (Error.message
         // getters, toString) that re-entrantly cancel the client or abort the
         // upstream. Build the tail FIRST, then re-check eligibility before
         // committing to the synthetic terminal (adversarial review blocker).
-        const tail = new TextEncoder().encode(
-          `\n\nevent: response.failed\ndata: ${buildFailedTailPayload(err)}\n\ndata: [DONE]\n\n`,
-        );
-        if (!hooks.sawTerminal() && !cancelled && !upstream.signal.aborted) {
-          syntheticKind = "failed";
+        const tail = encodeFailedTail(err);
+        if (tail && !cancelled && !upstream.signal.aborted) {
+          // Inspection and client framing have separate bounded parsers. If
+          // inspection resynchronized after an oversized frame and observed a
+          // later real terminal, it still must not suppress a terminal delivery
+          // to the client. Only accounting remains tied to the inspected result.
+          if (!hooks.sawTerminal()) syntheticKind = "failed";
+          deliveryFallbackSent = true;
           queuedBytes += tail.byteLength;
           try { controllerRef?.enqueue(tail); } catch { /* client already torn down */ }
           try { controllerRef?.close(); } catch { /* client already torn down */ }
@@ -306,7 +433,7 @@ export function relaySseEagerBounded(
       if (cancelled && !hooks.sawTerminal()) {
         hooks.onClientCancel();
       }
-      if (cancelled || upstream.signal.aborted || syntheticKind === "failed") {
+      if (cancelled || upstream.signal.aborted || syntheticKind === "failed" || deliveryFallbackSent) {
         upstream.abort();
         reader.cancel().catch(() => {});
       }

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 {
@@ -16,6 +24,7 @@ import {
   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>();
@@ -24,6 +33,30 @@ 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;
@@ -99,6 +132,21 @@ 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;
@@ -111,13 +159,16 @@ export type SseTerminalOutputBoundary = {
  * 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.
+ * 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 = (
@@ -129,16 +180,37 @@ export function createSseTerminalOutputBoundary(): SseTerminalOutputBoundary {
     for (const frame of frames) {
       const payload = sseDataPayload(decoder.decode(frame.block));
       const isDone = payload === "[DONE]";
-      // Preserve every frame through the first Responses terminal. A [DONE]
-      // frame is also preserved when it immediately follows that terminal in
-      // the same upstream chunk; every later non-DONE frame is dropped.
-      if (!responsesTerminal || isDone) output.push(frame.block, frame.delimiter);
+      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;
       }
-      if (!responsesTerminal && payload && terminalStatusFromSsePayload(payload)) {
+      // 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) {
@@ -155,13 +227,22 @@ export function createSseTerminalOutputBoundary(): SseTerminalOutputBoundary {
     },
     finish() {
       if (disposed || terminal) return new Uint8Array(0);
-      return framer.finish();
+      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();
     },
   };
@@ -198,7 +279,7 @@ export function relaySseWithFailedTail(
     // 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(encoder.encode("data: [DONE]\n\n"));
+      controller.enqueue(doneFrame(encoder));
     }
     closed = true;
     controller.close();
@@ -219,6 +300,16 @@ export function relaySseWithFailedTail(
           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;
@@ -228,8 +319,10 @@ export function relaySseWithFailedTail(
         }
       } catch (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
@@ -237,11 +330,14 @@ export function relaySseWithFailedTail(
         }
         terminalBoundary.dispose();
         if (closed) return;
-        const payload = buildFailedTailPayload(err);
         try {
           if (partial.byteLength > 0) controller.enqueue(partial);
-          // 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 (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();
@@ -276,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;
@@ -322,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;
   }
@@ -800,6 +1022,9 @@ export function createSseInspector(handlers: SseInspectorHandlers): SseInspector
     }
     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 {
@@ -808,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();
       }
@@ -1087,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 {