@bitkyc08/opencodex 2.57.0 → 2.58.0

package/src/server/responses/codex-ws-exchange.ts

@@ -1,3 +1,6 @@
+import { mergeSteeringContinuation } from "./native-steering-settings";
+import { markNativeControlResponse } from "./native-response-control";
+import type { NativeResponseControl } from "./native-response-control";
 import { MAX_CLIENT_SSE_FRAME_BYTES } from "../sse-frame-buffer";
 import { isSafeResponseHeader } from "../safe-response-headers";
 import { CodexWsMetadata, type CodexWsQuotaObserver } from "./codex-ws-metadata";
@@ -6,10 +9,12 @@ import { CodexWsCorrelation } from "./codex-ws-correlation";
 import type { CodexWsSession } from "./codex-ws-session";
 import { UPGRADE_DEADLINE_MS, CODEX_WS_LIVENESS_PING_INTERVAL_MS, CODEX_WS_RESPONSE_PRELUDE_TIMEOUT_MS, MAX_CODEX_WS_FRAME_BYTES,
   MAX_CODEX_WS_QUEUE_BYTES, markCodexWsResponse, normalizeResponsesWsRelayEvent, closedBeforeTerminalMessage,
-  codexWsFailureDetail, codexWsPreResponseFailure, markCodexWsStage, codexWsOcxVersion,
+  codexWsCreateFrameExceedsLimit, codexWsFailureDetail, codexWsPreResponseFailure, markCodexWsStage, codexWsOcxVersion,
   type CodexWsFailureStage, type CodexWsStageRecord } from "./codex-ws-wire";
 
 interface ExchangeOptions {
+  nativeControl?: NativeResponseControl;
+  beforeContinuation?: () => Promise<void>;
   session: CodexWsSession;
   url: string;
   init: RequestInit;
@@ -86,7 +91,7 @@ function wrappedRejectionResponse(payload: Record<string, unknown>, prelude: Hea
 
 /** The sole SSE exchange state machine for both one-shot and retained sockets. */
 export function codexWsExchange(options: ExchangeOptions): Promise<Response> {
-  const { session, url, init, prepared, sseFallback, onQuota, beforeDispatch, bunVersion } = options;
+  const { session, url, init, prepared, sseFallback, onQuota, beforeDispatch, bunVersion, nativeControl, beforeContinuation } = options;
   const { frameText, headers } = prepared;
   const signal = init.signal ?? undefined;
   return new Promise<Response>((resolve, reject) => {
@@ -116,6 +121,8 @@ export function codexWsExchange(options: ExchangeOptions): Promise<Response> {
     const metadata = url === CODEX_RESPONSES_HTTP_URL ? new CodexWsMetadata(onQuota) : null;
     const correlation = session.retainable ? new CodexWsCorrelation(session.reused, id => session.hasCompleted(id)) : null;
     let detachOwner = () => {};
+    let detachSteering = () => {};
+    let continuationBase: Record<string, unknown> | undefined;
     // Liveness while waiting for the first response event (metadata path only): the
     // silence timer is re-armed by every inbound frame or pong; the pinger runs on a fixed
     // interval so a peer that answers pings can never trip the silence bound while alive.
@@ -142,6 +149,7 @@ export function codexWsExchange(options: ExchangeOptions): Promise<Response> {
       metadata?.finish();
       correlation?.finish();
       detachOwner();
+      detachSteering();
       ws.removeEventListener("open", onOpen);
       ws.removeEventListener("message", onMessage);
       ws.removeEventListener("close", onClose);
@@ -198,6 +206,7 @@ export function codexWsExchange(options: ExchangeOptions): Promise<Response> {
       const response = new Response(stream, { status: 200, headers: responseHeaders });
       metadata?.commit();
       markCodexWsResponse(response, Boolean(metadata && onQuota));
+      if (nativeControl) markNativeControlResponse(response);
       markCodexWsStage(response, stageRecord(null));
       committedResponse = response;
       resolve(response);
@@ -329,6 +338,54 @@ export function codexWsExchange(options: ExchangeOptions): Promise<Response> {
       }
       if (terminal || settledPreOpen || signal?.aborted) return;
       sent = true;
+      try {
+        if (nativeControl) {
+          // Parsed once: the base body is immutable for this exchange, and a
+          // full-replay frame runs to megabytes. It seeds continuationBase on
+          // the first create frame.
+          let base: Record<string, unknown> | undefined;
+          detachSteering = nativeControl.attach(frame => {
+            const sendControl = () => {
+              if (terminal || signal?.aborted || session.closed || ws.readyState !== WebSocket.OPEN) {
+                throw new Error("Native steering connection is no longer available");
+              }
+              beforeDispatch?.(new Headers(headers));
+              let outgoing = frame;
+              if (frame.type === "response.create") {
+                // Generation overrides have passed route policy; identity/tools remain pinned.
+                // Keep the last explicit wire settings for later explicit and automatic successors.
+                base ??= JSON.parse(frameText) as Record<string, unknown>;
+                continuationBase ??= base;
+                outgoing = nativeControl.kind === "steering"
+                  ? mergeSteeringContinuation(continuationBase, frame)
+                  : { ...continuationBase, input: frame.input, previous_response_id: frame.previous_response_id };
+              }
+              const text = JSON.stringify(outgoing);
+              if (codexWsCreateFrameExceedsLimit(text)) {
+                throw new Error("Native steering frame exceeds the transport byte limit");
+              }
+              if (frame.type === "response.create") continuationBase = outgoing;
+              try { ws.send(text); } catch {
+                // A send failure has unknown delivery. Never replay or fall back.
+                failStream("Native steering send failed; delivery is unknown");
+                throw new Error("Native steering send failed; delivery is unknown");
+              }
+            };
+            if (frame.type === "response.create" && beforeContinuation) {
+              // Explicit tool-result continuations are physical request starts;
+              // they keep provider pacing and revalidate auth AFTER the wait.
+              void beforeContinuation().then(sendControl).catch(() => failStream("Native steering continuation could not be dispatched; do not automatically replay queued input"));
+            } else sendControl();
+          }, error => failStream(error));
+        }
+      } catch (error) {
+        // An attach failure is an ownership conflict, not a failed send: no frame
+        // left the process, but the channel can never bind, so resolving the HTTP
+        // fallback here would silently degrade a multi-agent turn into an ordinary
+        // one. Fail the turn visibly instead.
+        failStream(error);
+        return;
+      }
       try {
         ws.send(frameText);
         sentAt = Date.now();
@@ -400,8 +457,12 @@ export function codexWsExchange(options: ExchangeOptions): Promise<Response> {
         return;
       }
       if (!controlFrame && !type.startsWith("response.") && type !== "error") return;
+      let steeringEnded = false;
       if (!controlFrame) {
-        try { correlation?.accept(normalized.payload); } catch (error) { failStream(error); return; }
+        try {
+          if (nativeControl) steeringEnded = nativeControl.observe(normalized.payload);
+          else correlation?.accept(normalized.payload);
+        } catch (error) { failStream(error); return; }
         // Correlation must run first: a reused socket's foreign-stream error settles as a
         // non-replayable 502 above, never as the refused-create 4xx projection below, which
         // is the one status family that could authorize an account replay.
@@ -443,7 +504,7 @@ export function codexWsExchange(options: ExchangeOptions): Promise<Response> {
         return;
       }
       if (!controlFrame) relayedEvents += 1;
-      if (type === "response.completed" || type === "response.failed" || type === "response.incomplete" || type === "error") {
+      if (nativeControl ? steeringEnded : (type === "response.completed" || type === "response.failed" || type === "response.incomplete" || type === "error")) {
         const completedId = correlation?.completed(normalized.payload) ?? null;
         terminal = true;
         cleanup();

package/src/server/responses/combo-stream-preflight.ts

@@ -1,4 +1,6 @@
 import type { ResponsesTerminalStatus } from "../../bridge";
+import { comboFailureDecision } from "../../combos";
+import { httpStatusFromTerminalError } from "../../lib/errors";
 import type { RequestLogContext } from "../request-log";
 import { createSseInspector } from "../relay";
 import { MAX_CLIENT_SSE_FRAME_BYTES } from "../sse-frame-buffer";
@@ -30,12 +32,67 @@ const RETRYABLE_ZERO_OUTPUT_INCOMPLETE_REASONS = new Set([
   "upstream_stall_timeout",
 ]);
 
+function bareErrorStatus(payload: unknown): number | undefined {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return undefined;
+  const event = payload as Record<string, unknown>;
+  if (event.type !== "error") return undefined;
+  const nested = event.error;
+  const error = nested && typeof nested === "object" && !Array.isArray(nested)
+    ? nested as Record<string, unknown>
+    : event;
+  const explicitStatus = [
+    event.status,
+    event.status_code,
+    event.http_status,
+    error.status,
+    error.status_code,
+    error.http_status,
+  ]
+    .map(value => typeof value === "number" && Number.isInteger(value)
+      ? value
+      : typeof value === "string" && /^\d{3}$/.test(value.trim())
+        ? Number(value)
+        : undefined)
+    .find(value => value !== undefined && value >= 400 && value <= 599);
+  const code = typeof error.code === "string"
+    ? error.code
+    : typeof event.code === "string" ? event.code : null;
+  if (explicitStatus === undefined && code === "invalid_request_error") return 400;
+  return explicitStatus ?? httpStatusFromTerminalError({
+    type: typeof error.type === "string" && error.type !== "error" ? error.type : undefined,
+    code,
+    message: typeof error.message === "string"
+      ? error.message
+      : typeof event.message === "string" ? event.message : undefined,
+  });
+}
+
+function bareErrorIsRetryable(payload: unknown): boolean {
+  const status = bareErrorStatus(payload);
+  if (status === undefined || !payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return false;
+  }
+  const event = payload as Record<string, unknown>;
+  const nested = event.error;
+  const error = nested && typeof nested === "object" && !Array.isArray(nested)
+    ? nested as Record<string, unknown>
+    : event;
+  const code = typeof error.code === "string"
+    ? error.code
+    : typeof event.code === "string" ? event.code : null;
+  const message = typeof error.message === "string"
+    ? error.message
+    : typeof event.message === "string" ? event.message : "";
+  return comboFailureDecision(status, message, { code }) === "hop";
+}
+
 function retryableZeroOutputTerminal(payload: unknown): boolean {
   if (!payload || typeof payload !== "object" || Array.isArray(payload)) return false;
   const event = payload as {
     type?: unknown;
     response?: { incomplete_details?: { reason?: unknown } };
   };
+  if (bareErrorIsRetryable(event)) return true;
   if (event.type === "response.failed") return true;
   if (event.type !== "response.incomplete") return false;
   const reason = event.response?.incomplete_details?.reason;
@@ -95,12 +152,17 @@ function failedTerminalResponse(
     ? nested as Record<string, unknown>
     : {};
   const nestedError = terminalResponse.error;
+  const topLevelError = terminalPayload.error;
   const error = nestedError && typeof nestedError === "object" && !Array.isArray(nestedError)
     ? nestedError as Record<string, unknown>
+    : topLevelError && typeof topLevelError === "object" && !Array.isArray(topLevelError)
+      ? topLevelError as Record<string, unknown>
     : {
       type: "upstream_error",
       code: "upstream_server_error",
-      message: logCtx.upstreamError ?? "Provider stream failed before producing output",
+      message: typeof terminalPayload.message === "string"
+        ? terminalPayload.message
+        : logCtx.upstreamError ?? "Provider stream failed before producing output",
     };
   const headers = new Headers(response.headers);
   headers.set("content-type", "application/json");
@@ -117,7 +179,7 @@ function failedTerminalResponse(
       ...(usage && typeof usage === "object" && !Array.isArray(usage) ? { usage } : {}),
     },
   }), {
-    status: logCtx.terminalHttpStatus ?? 502,
+    status: logCtx.terminalHttpStatus ?? bareErrorStatus(terminalPayload) ?? 502,
     headers,
   });
 }
@@ -154,11 +216,12 @@ export async function preflightComboStreamResponse(
   const inspector = createSseInspector({
     logCtx,
     onParsedPayload: payload => {
+      if (terminalStatus !== undefined || outputCommitted || retryableTerminalPayload) return;
       const retryable = retryableTerminal(payload);
       const matchedBareError = retryable && payload !== null && typeof payload === "object"
         && !Array.isArray(payload) && (payload as { type?: unknown }).type === "error";
-      // Only an explicit caller predicate may opt a known bare error into replay.
-      // Default combo classification still commits unknown/error events.
+      // A zero-output bare error is terminal evidence. Explicit client errors stay
+      // committed; unknown and retryable upstream failures may advance the combo.
       if (comboStreamPayloadCommitsOutput(payload) && !matchedBareError) outputCommitted = true;
       if (!payload || typeof payload !== "object" || Array.isArray(payload)) return;
       if (retryable) retryableTerminalPayload = payload as Record<string, unknown>;
@@ -197,7 +260,7 @@ export async function preflightComboStreamResponse(
       }
 
       // A bare error event is not a protocol terminal (terminalStatus stays undefined),
-      // so its exact-message retryable match doubles as the terminal evidence.
+      // so its retryable classification doubles as the terminal evidence.
       if ((terminalStatus === "failed" || terminalStatus === "incomplete"
         || retryableTerminalPayload?.type === "error")
         && !outputCommitted && retryableTerminalPayload) {

package/src/server/responses/core-combo.ts

@@ -745,6 +745,13 @@ export async function executeComboResponses(
       code: failure.upstreamCode,
       message: failure.classificationText,
     });
+    // Same target selector as the exclusionary pick below, minus `exclude`: the only
+    // difference is deliberate and is the whole point of the single-target retry.
+    const retryAfterCooldown = () =>
+      pickWithWait({
+        eligible: targetEligible,
+        now: failureNow,
+      });
     if (nextPick) {
       pick = nextPick;
     } else {
@@ -753,6 +760,25 @@ export async function executeComboResponses(
         eligible: targetEligible,
         now: failureNow,
       });
+      // A single-target combo with waitForCooldownMs has no alternate target to fail over to,
+      // but can recover if it waits for its brief cooldown. The initial attempt accumulated into
+      // pick.attempted, so the first pickWithWait above excluded it. retryAfterCooldown below is
+      // the same selector with `exclude` deliberately dropped, so the single cooled target
+      // becomes eligible again once its cooldown expires.
+      // Termination is double-guarded:
+      // 1) comboSendScope?.reserveDispatch refuses a second failover hop via comboExecutionBudgetPolicy
+      //    (maxAlternateTargetSends: 1 for a single declared target).
+      // 2) comboTargetsDispatched <= 1 bounds it locally so the retry never loops or waits unnecessarily
+      //    even if sendBudget scope is absent.
+      if (
+        !pick
+        && combo.targets.length === 1
+        && combo.waitForCooldownMs > 0
+        && comboTargetsDispatched <= 1
+        && !options.abortSignal?.aborted
+      ) {
+        pick = await retryAfterCooldown();
+      }
     }
     if (!pick) {
       if (options.abortSignal?.aborted) return clientCancelledResponse();

package/src/server/responses/core-options.ts

@@ -1,3 +1,4 @@
+import type { NativeResponseControl } from "./native-response-control";
 import type { OcxUsage, OcxProviderContinuationState, OcxConfig } from "../../types";
 import type { CodexAuthPolicyConfig, CodexAuthContext } from "../../codex/auth-context";
 import type { AdmissionLease } from "../../lib/admission";
@@ -51,6 +52,8 @@ export interface HandleResponsesOptions {
   /** Called at most once after the complete client body is read and accepted for dispatch. */
   onRequestBodyRead?: () => void;
   forceEmptyResponseId?: boolean;
+  /** Internal, connection-owned control channel; never reconstructed from headers. */
+  nativeControl?: NativeResponseControl;
   abortSignal?: AbortSignal;
   /** One-shot TTFT callback: first non-empty model output observed (WP4). */
   onFirstOutput?: () => void;

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

@@ -1,3 +1,4 @@
+import type { NativeResponseControl } from "./native-response-control";
 import type { Server } from "bun";
 import {
   codexWsUpstreamFetch,
@@ -53,6 +54,7 @@ export interface PaceAwareFetch {
 export type ProviderFetch = typeof globalThis.fetch & PaceAwareFetch;
 
 export interface ProviderFetchOptions {
+  nativeControl?: NativeResponseControl;
   providerName?: string;
   modelId?: string;
   /** One pacing slot was acquired immediately before this fetch wrapper was created. */
@@ -101,7 +103,8 @@ export function providerFetch(
       // 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, options.onCodexWsQuota, options.beforeDispatch);
+      return codexWsUpstreamFetch(input, init, httpFetch, runtime, options.onCodexWsQuota, options.beforeDispatch, options.nativeControl,
+        () => waitForPacing(init.signal ?? undefined));
     }
     return httpFetch(input, init);
   };

package/src/server/responses/native-injection-protocol.ts

@@ -0,0 +1,42 @@
+import { nativeResponseRecord as injectionRecord } from "./native-response-json";
+export { nativeResponseRecord as injectionRecord, nativeResponseFingerprint as injectionFingerprint } from "./native-response-json";
+import { CODEX_WS_ID_MAX_BYTES } from "./codex-ws-correlation";
+import { NativeSteeringError } from "./native-steering";
+
+export type InjectionFrame = Record<string, unknown>;
+export type FunctionResult = { type: "function_call_output"; call_id: string; output: string };
+export const MAX_NATIVE_INJECTIONS = 32;
+export const MAX_NATIVE_INJECTION_BYTES = 8 * 1024 * 1024;
+export const MAX_NATIVE_INJECTION_CALLS = 1024;
+export const NATIVE_INJECTION_ACK_MS = 90_000;
+export const NATIVE_INJECTION_TOOL_MS = 30 * 60_000;
+
+/** Bound identities and exclude control characters, without changing their spelling. */
+export function injectionId(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0 && Buffer.byteLength(value) <= CODEX_WS_ID_MAX_BYTES
+    && !/[\u0000-\u001f\u007f]/.test(value);
+}
+/** Throw only fixed, content-free errors, never tool output or caller identifiers. */
+export function injectionError(code: string, message: string): never {
+  throw new NativeSteeringError(code, message);
+}
+/** First-version contract: nonempty arrays of string-valued, client-owned function results. */
+export function injectionResults(value: unknown): FunctionResult[] {
+  if (!Array.isArray(value) || !value.length || value.length > MAX_NATIVE_INJECTION_CALLS) {
+    injectionError("invalid_injection", "Supply a bounded, nonempty array of saved function results.");
+  }
+  const seen = new Set<string>();
+  for (const item of value) {
+    if (!injectionRecord(item) || item.type !== "function_call_output" || !injectionId(item.call_id)
+      || typeof item.output !== "string" || Object.keys(item).some(key => !["type", "call_id", "output"].includes(key))) {
+      injectionError("invalid_injection", "Only function_call_output with call_id and string output is supported; no messages or hosted-tool results.");
+    }
+    if (seen.has(item.call_id)) injectionError("duplicate_injection", "A function result must occur exactly once.");
+    seen.add(item.call_id);
+  }
+  return value as FunctionResult[];
+}
+/** Detect explicit multi-agent opt-in without inferring it from the model name. */
+export function isInjectionRequest(frame: InjectionFrame): boolean {
+  return injectionRecord(frame.multi_agent) && frame.multi_agent.enabled === true;
+}

package/src/server/responses/native-injection-replay.ts

@@ -0,0 +1,105 @@
+import { MAX_NATIVE_STEERING_REPLAY_BYTES, type NativeSteeringReplayObserver } from "./native-steering-replay";
+import { injectionRecord as record, type InjectionFrame as Frame, type FunctionResult } from "./native-injection-protocol";
+
+import { nativeResultFingerprint } from "./native-tool-results";
+import { nativeResponseOutput } from "./native-response-output";
+
+/** A bounded journal of accepted tool results, independent of user steering history. */
+export class NativeInjectionReplay implements NativeSteeringReplayObserver {
+  private prefix: unknown[];
+  private bytes = 0;
+  private current?: string;
+  private output = new Map<number, Frame>();
+  private accepted = new Map<string, FunctionResult>();
+  private pending?: FunctionResult[];
+  private pendingBytes = 0;
+  private acceptedBatchBytes: number[] = [];
+  private explicit: unknown[] = [];
+  private previous: unknown[] = [];
+
+  /** Capture a private initial prefix; existing persistence eligibility is checked by the caller. */
+  constructor(input: unknown, private readonly remember: (input: unknown[], response: Frame) => void) {
+    this.prefix = typeof input === "string"
+      ? [{ type: "message", role: "user", content: [{ type: "input_text", text: input }] }]
+      : Array.isArray(input) ? [...input] : [];
+    this.reserve(this.prefix);
+  }
+  /** Charge serialized bytes, refusing rather than truncating an over-budget transcript. */
+  private reserve(value: unknown): number {
+    const bytes = Buffer.byteLength(JSON.stringify(value));
+    if (this.bytes + bytes > MAX_NATIVE_STEERING_REPLAY_BYTES) throw new Error("Native injection replay exceeded its history budget.");
+    this.bytes += bytes;
+    return bytes;
+  }
+  /** Journal before physical send, with rollback usable only for a known unsent frame. */
+  submitted(frame: Frame): () => void {
+    const input = Array.isArray(frame.input) ? structuredClone(frame.input) : [];
+    const bytes = this.reserve(input);
+    if (frame.type === "response.inject") { this.pending = input as FunctionResult[]; this.pendingBytes = bytes; }
+    else this.explicit = input;
+    return () => {
+      if (frame.type === "response.inject") { this.pending = undefined; this.pendingBytes = 0; }
+      else this.explicit = [];
+      this.bytes -= bytes;
+    };
+  }
+  /** Keep wire output order and insert each accepted result after its owning function call. */
+  private completedOutput(response: Frame): unknown[] {
+    const output = nativeResponseOutput(this.output, response.output);
+    const echoed = new Set<string>();
+    for (const item of output) {
+      if (!record(item) || item.type !== "function_call_output" || typeof item.call_id !== "string") continue;
+      const accepted = this.accepted.get(item.call_id);
+      if (accepted) {
+        if (echoed.has(item.call_id) || nativeResultFingerprint(item as FunctionResult) !== nativeResultFingerprint(accepted)) throw new Error("Native injection replay result mismatch.");
+        echoed.add(item.call_id);
+      }
+    }
+    const merged: unknown[] = [];
+    const found = new Set(echoed);
+    for (const item of output) {
+      merged.push(item);
+      if (!record(item) || item.type !== "function_call" || typeof item.call_id !== "string") continue;
+      const accepted = this.accepted.get(item.call_id);
+      if (accepted && !found.has(item.call_id)) { merged.push(accepted); found.add(item.call_id); }
+    }
+    if (found.size !== this.accepted.size) throw new Error("Native injection replay is missing an accepted result's call.");
+    return merged;
+  }
+  /** Terminals are supplied by the owner only after all injection acknowledgements settle. */
+  observe(frame: Frame): void {
+    if (frame.type === "response.created") {
+      if (this.current) {
+        for (const item of this.previous) this.prefix.push(item);
+        for (const item of this.explicit) this.prefix.push(item);
+      }
+      this.current = String(record(frame.response) ? frame.response.id : "");
+      this.output.clear(); this.accepted.clear(); this.acceptedBatchBytes = []; this.explicit = []; this.previous = [];
+    } else if (frame.type === "response.inject.created" || frame.type === "response.inject.failed") {
+      if (!this.pending) throw new Error("Native injection replay acknowledgement has no pending input.");
+      if (frame.type === "response.inject.created") {
+        for (const item of this.pending) this.accepted.set(item.call_id, item);
+        this.acceptedBatchBytes.push(this.pendingBytes);
+      } else this.bytes -= this.pendingBytes;
+      this.pending = undefined; this.pendingBytes = 0;
+    } else if (frame.type === "response.output_item.done") {
+      if (!Number.isSafeInteger(frame.output_index) || (frame.output_index as number) < 0
+        || (frame.output_index as number) > 10_000 || !record(frame.item)) throw new Error("Native injection replay output identity is invalid.");
+      const old = this.output.get(frame.output_index as number);
+      if (old) this.bytes -= Buffer.byteLength(JSON.stringify(old));
+      this.reserve(frame.item); this.output.set(frame.output_index as number, structuredClone(frame.item));
+    } else if (record(frame.response) && ["response.completed", "response.failed", "response.incomplete"].includes(String(frame.type))) {
+      if (this.pending) throw new Error("Native injection replay cannot commit an unacknowledged result.");
+      const output = this.completedOutput(frame.response);
+      for (const item of this.output.values()) this.bytes -= Buffer.byteLength(JSON.stringify(item));
+      for (const bytes of this.acceptedBatchBytes) this.bytes -= bytes;
+      this.reserve(output); this.output.clear(); this.accepted.clear(); this.acceptedBatchBytes = []; this.previous = output;
+      if (frame.type === "response.completed") this.remember(this.prefix, { ...frame.response, output });
+    }
+  }
+  /** Drop all retained bodies at cancellation, connection teardown or unknown delivery. */
+  dispose(): void {
+    this.prefix = []; this.output.clear(); this.accepted.clear(); this.pending = undefined; this.pendingBytes = 0; this.acceptedBatchBytes = [];
+    this.explicit = []; this.previous = []; this.bytes = 0;
+  }
+}