@bitkyc08/opencodex 2.7.36 → 2.7.38-preview.20260724

package/src/server/relay-eager.ts

@@ -0,0 +1,199 @@
+/**
+ * Eager bounded single-reader SSE relay (#314 mitigation, WP2).
+ *
+ * Replaces the tee()+background-inspection passthrough shape on runtimes where
+ * the Bun#32111 async-pull cancel fix is present (src/lib/bun-stream-caps.ts):
+ * ONE eager producer loop reads upstream, feeds every chunk through the shared
+ * SSE inspector (terminal outcome, quota, request log, context cache), and
+ * enqueues it into a byte-bounded client queue. When the queue is full the
+ * producer pauses — no unbounded tee branch queue can build up behind a slow
+ * client.
+ *
+ * Honesty caveats (audit M5): full leak relief additionally assumes the
+ * runtime carries the Bun#29831 fetch receive-backpressure fix and that Bun's
+ * native Response sink pull-paces a JS ReadableStream. Neither is provable in
+ * bun:test (a JS reader always paces); both remain "awaiting Windows user
+ * verification".
+ *
+ * #44 cancel semantics: after client cancel the relay keeps reading upstream in
+ * DISCARD-DRAIN mode (inspection only) until a terminal is seen or the bounded
+ * drain window (ms/bytes) expires — a genuinely reached terminal records as
+ * completed/failed, never downgraded to cancel. Only when no terminal arrives
+ * within bounds does onClientCancel fire. This bounds today's unbounded tee
+ * drain; the tradeoff is that client-cancel log finalization may be delayed by
+ * up to the drain window.
+ */
+
+export type EagerRelayHooks = {
+  /** Feed one upstream chunk through SSE inspection (createSseInspector.feed). */
+  inspectChunk: (chunk: Uint8Array) => void;
+  /** Flush inspection at upstream end (createSseInspector.finish). */
+  finishInspection: () => void;
+  /** True once inspection has reported a protocol terminal (inspector.reported). */
+  sawTerminal: () => boolean;
+  /** Record a synthetic terminal (caller decides incomplete vs failed-502). */
+  onSynthetic: (kind: "incomplete" | "failed") => void;
+  /** Client cancelled and NO terminal arrived within the drain bounds. */
+  onClientCancel: () => void;
+  /** Exactly once, after the producer fully stops (unregisterTurn parity). */
+  onDone: () => void;
+};
+
+export type EagerRelayOptions = {
+  /** Bounded client queue in bytes; producer pauses above it. Default 8 MiB. */
+  maxQueueBytes?: number;
+  /** Post-cancel discard-drain wall-clock bound. Default 15 000 ms. */
+  postCancelDrainMs?: number;
+  /** Post-cancel discard-drain byte bound. Default 32 MiB. */
+  postCancelDrainBytes?: number;
+  /** Injectable clock for tests. */
+  now?: () => number;
+};
+
+const DEFAULT_MAX_QUEUE_BYTES = 8 * 1024 * 1024;
+const DEFAULT_DRAIN_MS = 15_000;
+const DEFAULT_DRAIN_BYTES = 32 * 1024 * 1024;
+
+/**
+ * Relay `body` to the returned stream with eager bounded reading and inline
+ * inspection. `upstream` is aborted on cancel-drain expiry and observed for
+ * shutdown teardown (its abort wakes a paused producer and suppresses
+ * synthetic terminals — audit M3).
+ */
+export function relaySseEagerBounded(
+  body: ReadableStream<Uint8Array>,
+  upstream: AbortController,
+  hooks: EagerRelayHooks,
+  opts?: EagerRelayOptions,
+): ReadableStream<Uint8Array> {
+  const maxQueueBytes = opts?.maxQueueBytes ?? DEFAULT_MAX_QUEUE_BYTES;
+  const drainMs = opts?.postCancelDrainMs ?? DEFAULT_DRAIN_MS;
+  const drainBytes = opts?.postCancelDrainBytes ?? DEFAULT_DRAIN_BYTES;
+  const now = opts?.now ?? Date.now;
+
+  const reader = body.getReader();
+  let queuedBytes = 0;
+  let cancelled = false;
+  let done = false;
+  // 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; });
+  upstream.signal.addEventListener("abort", wakeUp, { once: true });
+
+  let controllerRef: ReadableStreamDefaultController<Uint8Array> | null = null;
+  let doneFired = false;
+  let drainTimer: ReturnType<typeof setTimeout> | null = null;
+  const fireDone = () => {
+    if (doneFired) return;
+    doneFired = true;
+    if (drainTimer) { clearTimeout(drainTimer); drainTimer = null; }
+    try { hooks.onDone(); } catch { /* lifecycle callbacks must not break teardown */ }
+  };
+  // A silent upstream after cancel would park the drain loop in reader.read();
+  // the wall-clock bound must fire regardless, so cancel arms a hard timer that
+  // aborts upstream at the deadline (the abort wakes the read).
+  const armDrainTimer = () => {
+    if (drainTimer) return;
+    drainTimer = setTimeout(() => {
+      drainTimer = null;
+      upstream.abort(new Error("post-cancel drain window expired"));
+    }, drainMs);
+    (drainTimer as { unref?: () => void }).unref?.();
+  };
+
+  const producer = async () => {
+    let syntheticKind: "incomplete" | "failed" | null = null;
+    // 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). Race every read against the abort
+    // signal so cancel-drain expiry and shutdown teardown ALWAYS break the
+    // loop even on a silent upstream.
+    const aborted: Promise<"aborted"> = new Promise(resolve => {
+      if (upstream.signal.aborted) resolve("aborted");
+      else upstream.signal.addEventListener("abort", () => resolve("aborted"), { once: true });
+    });
+    try {
+      for (;;) {
+        const result = await Promise.race([reader.read(), aborted]);
+        if (result === "aborted") break;
+        const { done: upstreamDone, value } = result;
+        if (upstreamDone) {
+          hooks.finishInspection();
+          if (!hooks.sawTerminal() && !cancelled && !upstream.signal.aborted) {
+            syntheticKind = "incomplete";
+          }
+          break;
+        }
+        hooks.inspectChunk(value);
+        if (cancelled) {
+          // Discard-drain: inspection only, nothing queued. Stop at terminal
+          // or when the bounded window expires.
+          drainedBytes += value.byteLength;
+          if (hooks.sawTerminal() || drainedBytes >= drainBytes || now() >= drainDeadline) {
+            break;
+          }
+          continue;
+        }
+        queuedBytes += value.byteLength;
+        try {
+          controllerRef?.enqueue(value);
+        } catch {
+          // Controller already torn down (client went away without cancel()).
+          cancelled = true;
+          drainDeadline = now() + drainMs;
+          armDrainTimer();
+          continue;
+        }
+        while (queuedBytes > maxQueueBytes && !cancelled && !upstream.signal.aborted) {
+          await paused();
+        }
+      }
+    } catch {
+      // Upstream read failure. Distinguish genuine mid-stream reset from
+      // abort-driven teardown (shutdown/cancel-expiry) — audit M3.
+      if (!hooks.sawTerminal() && !cancelled && !upstream.signal.aborted) {
+        syntheticKind = "failed";
+        try { controllerRef?.error(new Error("upstream stream failed")); } catch { /* torn down */ }
+      }
+    } finally {
+      if (syntheticKind) hooks.onSynthetic(syntheticKind);
+      if (cancelled && !hooks.sawTerminal()) {
+        hooks.onClientCancel();
+      }
+      if (cancelled || upstream.signal.aborted) {
+        upstream.abort();
+        reader.cancel().catch(() => {});
+      }
+      if (!cancelled) {
+        try { controllerRef?.close(); } catch { /* already closed/errored */ }
+      }
+      fireDone();
+    }
+  };
+
+  let drainedBytes = 0;
+  let drainDeadline = Number.POSITIVE_INFINITY;
+
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      controllerRef = controller;
+      void producer();
+    },
+    pull() {
+      // The client consumed from the queue; approximate accounting: reset on
+      // pull below cap. desiredSize reflects internal queue in chunks, not
+      // bytes, so we track bytes ourselves and drain optimistically.
+      queuedBytes = 0;
+      wakeUp();
+    },
+    cancel() {
+      cancelled = true;
+      drainDeadline = now() + drainMs;
+      armDrainTimer();
+      wakeUp();
+    },
+  });
+}

package/src/server/relay.ts

@@ -159,15 +159,22 @@ export function completedResponseFromSsePayload(payload: string): { id?: unknown
   if (payload === "[DONE]") return null;
   try {
     const json = JSON.parse(payload) as { type?: unknown; response?: unknown };
-    if (json.type !== "response.completed") return null;
-    const response = json.response;
-    if (!response || typeof response !== "object" || Array.isArray(response)) return null;
-    return response as { id?: unknown; output?: unknown; status?: unknown };
+    return completedResponseFromParsedEvent(json);
   } catch {
     return null;
   }
 }
 
+/** Extract the response object from an already-parsed `response.completed` event, or null. */
+function completedResponseFromParsedEvent(
+  json: { type?: unknown; response?: unknown } | null,
+): { id?: unknown; output?: unknown; status?: unknown } | null {
+  if (!json || json.type !== "response.completed") return null;
+  const response = json.response;
+  if (!response || typeof response !== "object" || Array.isArray(response)) return null;
+  return response as { id?: unknown; output?: unknown; status?: unknown };
+}
+
 export function trackSseForRequestLog(
   body: ReadableStream<Uint8Array>,
   onTerminal: (status: ResponsesTerminalStatus) => void,
@@ -404,6 +411,116 @@ export function relaySseWithHeartbeat(
  * Background-consume an SSE stream purely for terminal-outcome inspection (quota tracking).
  * Does not produce output; safe to ignore errors (the client-facing stream is separate).
  */
+export type SseInspector = {
+  /** Feed one upstream chunk through the SSE scanning state machine. */
+  feed(chunk: Uint8Array): void;
+  /** Flush the decoder + trailing unterminated buffer (upstream cleanly done). */
+  finish(): void;
+  /** True once a protocol terminal was detected and reported. */
+  reported(): boolean;
+};
+
+/**
+ * Per-chunk SSE inspection state machine shared by consumeForInspection,
+ * consumeForResponseLogMetadata, and the eager bounded relay (relay-eager.ts).
+ *
+ * Extraction-fidelity invariants (devlog/_plan/260723_win_mem_safestream/020):
+ * - logCtx SSE inspection is gated on !reported; in the metadata configuration
+ *   (no onTerminal) `reported` stays permanently false, which reproduces the
+ *   metadata consumer's unconditional inspection through the same gate.
+ * - finish() skips the trailing-buffer scan once reported, while per-block
+ *   onCompletedResponse continues firing after reported — an intentional
+ *   asymmetry inherited from consumeForInspection.
+ * - logCtx.transportPhase/terminalSource are mutated BEFORE onTerminal fires.
+ * - Synthetic terminals (incomplete / failed-502) are the CALLER's decision:
+ *   the caller owns `cancelled` state and reads `reported()` to decide.
+ */
+export function createSseInspector(handlers: {
+  onTerminal?: (status: ResponsesTerminalStatus, httpStatusOverride?: number) => void;
+  logCtx?: RequestLogContext;
+  onCompletedResponse?: (response: { id?: unknown; output?: unknown; status?: unknown }) => void;
+  onFirstOutput?: () => void;
+}): SseInspector {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let reported = false;
+  const reportFirstOutput = createFirstOutputReporter(handlers.onFirstOutput);
+  // Allocate reconstruction state only for persistence-capable inspectors.
+  const completedItemsByOutputIndex = handlers.onCompletedResponse
+    ? new Map<number, unknown>()
+    : null;
+
+  const scanPayload = (payload: string | null): void => {
+    if (!reported && handlers.logCtx) inspectResponseLogSsePayload(handlers.logCtx, payload);
+    reportFirstOutput(payload);
+    if (!payload) return;
+    if (!reported && handlers.onTerminal) {
+      const status = terminalStatusFromSsePayload(payload);
+      if (status) {
+        reported = true;
+        if (handlers.logCtx) {
+          handlers.logCtx.transportPhase = "terminal_sse";
+          handlers.logCtx.terminalSource = "upstream";
+        }
+        handlers.onTerminal(status);
+      }
+    }
+    if (handlers.onCompletedResponse) {
+      type ParsedSseEvent = { type?: unknown; output_index?: unknown; item?: unknown; response?: unknown };
+      let parsedEvent: ParsedSseEvent | null = null;
+      try {
+        if (payload !== "[DONE]") parsedEvent = JSON.parse(payload) as ParsedSseEvent;
+      } catch {
+        /* malformed SSE payloads remain best-effort/no-throw */
+      }
+      const doneItem = parsedEvent?.type === "response.output_item.done" ? parsedEvent.item : undefined;
+      if (parsedEvent
+        && doneItem !== undefined
+        && Number.isInteger(parsedEvent.output_index)
+        && (parsedEvent.output_index as number) >= 0
+        && typeof doneItem === "object"
+        && doneItem !== null
+        && !Array.isArray(doneItem)
+        && typeof (doneItem as { type?: unknown }).type === "string") {
+        completedItemsByOutputIndex!.set(parsedEvent.output_index as number, doneItem);
+      }
+
+      let response = completedResponseFromParsedEvent(parsedEvent);
+      if (response
+        && (!Array.isArray(response.output) || response.output.length === 0)
+        && completedItemsByOutputIndex!.size > 0) {
+        response = {
+          ...response,
+          output: [...completedItemsByOutputIndex!.entries()]
+            .sort(([left], [right]) => left - right)
+            .map(([, item]) => item),
+        };
+      }
+      if (response) handlers.onCompletedResponse(response);
+    }
+  };
+
+  return {
+    feed(chunk) {
+      buffer += decoder.decode(chunk, { stream: true });
+      let next: { block: string; rest: string } | null;
+      while ((next = nextSseBlock(buffer))) {
+        buffer = next.rest;
+        if (reported && !handlers.onCompletedResponse) continue;
+        scanPayload(sseDataPayload(next.block));
+      }
+    },
+    finish() {
+      buffer += decoder.decode();
+      if (buffer.trim() && !reported) {
+        scanPayload(sseDataPayload(buffer));
+      }
+      buffer = "";
+    },
+    reported: () => reported,
+  };
+}
+
 export function consumeForInspection(
   body: ReadableStream<Uint8Array>,
   onTerminal: (status: ResponsesTerminalStatus, httpStatusOverride?: number) => void,
@@ -415,11 +532,8 @@ export function consumeForInspection(
   onFirstOutput?: () => void,
 ): void {
   const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let reported = false;
+  const inspector = createSseInspector({ onTerminal, logCtx, onCompletedResponse, onFirstOutput });
   let cancelled = false;
-  const reportFirstOutput = createFirstOutputReporter(onFirstOutput);
   if (signal) {
     if (signal.aborted) {
       // Aborted before we could read anything (Codex disconnects the instant it finishes reading).
@@ -444,64 +558,20 @@ export function consumeForInspection(
       for (;;) {
         const { done, value } = await reader.read();
         if (done) {
-          buffer += decoder.decode();
-          if (buffer.trim() && !reported) {
-            const payload = sseDataPayload(buffer);
-            if (logCtx) inspectResponseLogSsePayload(logCtx, payload);
-            reportFirstOutput(payload);
-            if (payload) {
-              const status = terminalStatusFromSsePayload(payload);
-              if (status) {
-                reported = true;
-                if (logCtx) {
-                  logCtx.transportPhase = "terminal_sse";
-                  logCtx.terminalSource = "upstream";
-                }
-                onTerminal(status);
-              }
-              if (onCompletedResponse) {
-                const response = completedResponseFromSsePayload(payload);
-                if (response) onCompletedResponse(response);
-              }
-            }
-          }
-          if (!reported && !cancelled) {
+          inspector.finish();
+          if (!inspector.reported() && !cancelled) {
             if (logCtx) logCtx.terminalSource = "synthetic";
             onTerminal("incomplete");
           }
           return;
         }
-        buffer += decoder.decode(value, { stream: true });
-        let next: { block: string; rest: string } | null;
-        while ((next = nextSseBlock(buffer))) {
-          buffer = next.rest;
-          if (reported && !onCompletedResponse) continue;
-          const payload = sseDataPayload(next.block);
-          if (!reported && logCtx) inspectResponseLogSsePayload(logCtx, payload);
-          reportFirstOutput(payload);
-          if (!payload) continue;
-          if (!reported) {
-            const status = terminalStatusFromSsePayload(payload);
-            if (status) {
-              reported = true;
-              if (logCtx) {
-                logCtx.transportPhase = "terminal_sse";
-                logCtx.terminalSource = "upstream";
-              }
-              onTerminal(status);
-            }
-          }
-          if (onCompletedResponse) {
-            const response = completedResponseFromSsePayload(payload);
-            if (response) onCompletedResponse(response);
-          }
-        }
+        inspector.feed(value);
       }
     } catch {
       // Upstream read failure after HTTP 200 (mid-stream socket reset) is not a
       // protocol `response.incomplete` terminal. Report a synthetic 502 so account
       // health treats it as transient; abort-driven client cancellation still wins.
-      if (!reported && !cancelled) {
+      if (!inspector.reported() && !cancelled) {
         if (logCtx) {
           logCtx.transportPhase = "mid_stream";
           logCtx.terminalSource = "synthetic";
@@ -524,9 +594,9 @@ export function consumeForResponseLogMetadata(
   onFirstOutput?: () => void,
 ): void {
   const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const reportFirstOutput = createFirstOutputReporter(onFirstOutput);
+  // No onTerminal → the inspector's `reported` gate stays permanently false,
+  // reproducing this consumer's unconditional logCtx inspection.
+  const inspector = createSseInspector({ logCtx, onCompletedResponse, onFirstOutput });
   if (signal) {
     if (signal.aborted) {
       reader.cancel(signal.reason).catch(() => {});
@@ -542,30 +612,10 @@ export function consumeForResponseLogMetadata(
       for (;;) {
         const { done, value } = await reader.read();
         if (done) {
-          buffer += decoder.decode();
-          if (buffer.trim()) {
-            const payload = sseDataPayload(buffer);
-            inspectResponseLogSsePayload(logCtx, payload);
-            reportFirstOutput(payload);
-            if (payload && onCompletedResponse) {
-              const response = completedResponseFromSsePayload(payload);
-              if (response) onCompletedResponse(response);
-            }
-          }
+          inspector.finish();
           return;
         }
-        buffer += decoder.decode(value, { stream: true });
-        let next: { block: string; rest: string } | null;
-        while ((next = nextSseBlock(buffer))) {
-          buffer = next.rest;
-          const payload = sseDataPayload(next.block);
-          inspectResponseLogSsePayload(logCtx, payload);
-          reportFirstOutput(payload);
-          if (payload && onCompletedResponse) {
-            const response = completedResponseFromSsePayload(payload);
-            if (response) onCompletedResponse(response);
-          }
-        }
+        inspector.feed(value);
       }
     } catch {
       /* metadata inspection must not affect the client-facing stream */

package/src/server/responses/collaboration.ts

@@ -281,11 +281,29 @@ export function subagentRosterText(models: Array<{ model: string; efforts: strin
 
 
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function isGeneratedDeveloperItem(item: unknown, text: string): boolean {
+  if (!isRecord(item) || item.type !== "message" || item.role !== "developer") return false;
+  if (!Array.isArray(item.content) || item.content.length !== 1) return false;
+  const [part] = item.content;
+  return isRecord(part) && part.type === "input_text" && part.text === text;
+}
+
 export function injectDeveloperMessage(parsed: OcxParsedRequest, text: string): void {
-  parsed.context.messages.push({ role: "developer", content: text, timestamp: Date.now() });
   const raw = parsed._rawBody as { input?: unknown } | undefined;
+  const devItem = { type: "message", role: "developer", content: [{ type: "input_text", text }] };
+  if (raw && Array.isArray(raw.input)) {
+    const replayPrefixLen = Math.min(parsed._replayPrefixLen ?? 0, raw.input.length);
+    if (raw.input.slice(0, replayPrefixLen).some(item => isGeneratedDeveloperItem(item, text))) {
+      return;
+    }
+  }
+
+  parsed.context.messages.push({ role: "developer", content: text, timestamp: Date.now() });
   if (raw && Array.isArray(raw.input)) {
-    const devItem = { type: "message", role: "developer", content: [{ type: "input_text", text }] };
     // compaction_trigger must remain the final input item (codex-rs + ChatGPT backend both
     // validate this). Insert the developer message BEFORE the trigger when present.
     const last = raw.input[raw.input.length - 1];
@@ -297,4 +315,3 @@ export function injectDeveloperMessage(parsed: OcxParsedRequest, text: string):
   }
 }
 
-

package/src/server/responses/core.ts

@@ -89,11 +89,14 @@ import type { AttemptRecoveryKind } from "../../usage/log";
 import {
   consumeForInspection,
   consumeForResponseLogMetadata,
+  createSseInspector,
   markNativePassthroughSseResponse,
   relaySseWithFailedTail,
   relayWithAbort,
   sanitizePassthroughHeaders,
 } from "../relay";
+import { relaySseEagerBounded } from "../relay-eager";
+import { decideEagerRelay } from "../../lib/bun-stream-caps";
 import { hasResponsesItemIdRepair, relaySseWithResponsesItemIdRepair } from "../responses-item-id-repair";
 import type { EffectiveSubagentRoster, SpawnAgentSurface } from "../../codex/catalog";
 
@@ -1021,9 +1024,57 @@ export async function handleResponses(
     // async-pull segfault on Windows. Branch[0] goes directly to the Response (Bun
     // native relay, never enters JS Sink.write); branch[1] is consumed in the
     // background for terminal-outcome/quota inspection only.
+    // #314 alternative shape: on win32 (no repair) with a runtime carrying the
+    // Bun#32111 fix — or explicit `streamMode: "eager-relay"` opt-in — the tee
+    // is skipped entirely and relaySseEagerBounded provides a single eager
+    // bounded reader with inline inspection (see src/server/relay-eager.ts and
+    // devlog/_plan/260723_win_mem_safestream/020). Default on the bundled
+    // known-bad runtime remains the tee path below.
     if (upstreamResponse.ok && isEventStream && upstreamResponse.body) {
-      const [nativeBody, inspectBody] = upstreamResponse.body.tee();
       const repairConfig = route.provider.responsesItemIdRepair;
+      const winNoRepair = process.platform === "win32" && !hasResponsesItemIdRepair(repairConfig);
+      const eagerDecision = winNoRepair ? decideEagerRelay(config.streamMode ?? "auto") : null;
+      if (eagerDecision?.useEagerRelay) {
+        const turnAc = new AbortController();
+        linkAbortSignal(upstream, turnAc.signal);
+        registerTurn(turnAc);
+        const reportNativeTerminal = recordTerminalOutcomes
+          ? (status: ResponsesTerminalStatus, httpStatusOverride?: number) => {
+            terminalRecorder?.(status, httpStatusOverride);
+            options.onNativePassthroughTerminal?.(status);
+          }
+          : undefined;
+        const inspector = createSseInspector({
+          onTerminal: reportNativeTerminal,
+          logCtx,
+          onCompletedResponse: rememberPassthroughResponse,
+          onFirstOutput: options.onFirstOutput,
+        });
+        const eagerBody = relaySseEagerBounded(upstreamResponse.body, turnAc, {
+          inspectChunk: chunk => inspector.feed(chunk),
+          finishInspection: () => inspector.finish(),
+          sawTerminal: () => inspector.reported(),
+          onSynthetic: kind => {
+            if (!reportNativeTerminal) return;
+            if (kind === "incomplete") {
+              logCtx.terminalSource = "synthetic";
+              reportNativeTerminal("incomplete");
+            } else {
+              logCtx.transportPhase = "mid_stream";
+              logCtx.terminalSource = "synthetic";
+              reportNativeTerminal("failed", 502);
+            }
+          },
+          onClientCancel: () => options.onNativePassthroughCancel?.(),
+          onDone: () => unregisterTurn(turnAc),
+        });
+        if (!headers.has("content-type")) headers.set("content-type", "text/event-stream");
+        return markNativePassthroughSseResponse(new Response(eagerBody, {
+          status: upstreamResponse.status,
+          headers,
+        }));
+      }
+      const [nativeBody, inspectBody] = upstreamResponse.body.tee();
       const turnAc = new AbortController();
       linkAbortSignal(upstream, turnAc.signal);
       registerTurn(turnAc);

package/src/types.ts

@@ -5,6 +5,8 @@ export interface OcxParsedRequest {
   stream: boolean;
   options: OcxRequestOptions;
   _rawBody?: unknown;
+  /** Number of leading raw input items restored from local previous_response_id state. */
+  _replayPrefixLen?: number;
   /** True when the proxy expanded a previous_response_id request into a full input replay. */
   _previousResponseInputExpanded?: boolean;
   /** Provider-private stable Cursor conversation id resolved from the Responses previous_response_id chain. */
@@ -445,6 +447,15 @@ export interface OcxConfig {
    * Undefined = passthrough (don't modify what the client sends).
    */
   fastMode?: boolean;
+  /**
+   * Windows SSE passthrough stream shape (#314 mitigation).
+   * "auto" (default): eager bounded relay only on runtimes proven to carry the
+   * Bun#32111 fix (none today → legacy tee). "eager-relay": force the new relay
+   * (accepts #32111 crash risk on Bun 1.3.14). "legacy-tee": pin the tee path.
+   * Persisted in config.json because Windows services do not inherit shell env.
+   * See src/lib/bun-stream-caps.ts.
+   */
+  streamMode?: "auto" | "legacy-tee" | "eager-relay";
   /**
    * Custom override for the injected multi-agent guidance body (the text inside the
    * <multi_agent_mode> tags). When set, it replaces the built-in prompt on whichever

package/src/usage/expected-prices.ts

@@ -130,3 +130,22 @@ export function findExpectedPriceOverlay(
   return exact.find(row => row.status === "verified")
     ?? exact.find(row => row.status === "verified-derived");
 }
+
+/**
+ * OpenAI service_tier "priority" (Fast) price multipliers by model slug.
+ * Source: https://platform.openai.com/docs/models (2026-07-24).
+ * Priority pricing applies uniformly to all token types (input, output, cache).
+ * Models not listed here fall back to 1× (no multiplier).
+ */
+export const PRIORITY_MULTIPLIERS: Readonly<Record<string, number>> = {
+  "gpt-5.6-sol": 2,
+  "gpt-5.6-terra": 2,
+  "gpt-5.6-luna": 2,
+  "gpt-5.5": 2.5,
+  "gpt-5.4": 2,
+};
+
+/** Returns the priority-tier price multiplier for a model (1 if not listed). */
+export function resolvePriorityMultiplier(modelId: string): number {
+  return PRIORITY_MULTIPLIERS[modelId] ?? 1;
+}