@criogaid/pi-codex-compaction 0.4.1 → 0.5.0

package/src/remote-retry.ts

@@ -0,0 +1,277 @@
+// Own bounded V2 retry evidence before Pi adapters reduce errors to message strings.
+import { setTimeout as delay } from "node:timers/promises";
+import { isObject } from "./protocol.js";
+
+const MAX_RETRIES = 2;
+const MAX_RETRY_DELAY_MS = 60_000;
+const MAX_OBSERVED_EVENT_CHARS = 1_048_576;
+const TRANSIENT_HTTP = new Set([408, 409, 429, 500, 502, 503, 504]);
+const TRANSIENT_CODES = new Set(["server_error", "server_is_overloaded", "rate_limit_exceeded", "slow_down"]);
+const PERMANENT_CODES = new Set([
+  "insufficient_quota", "credit_balance_exhausted", "organization_spend_limit_exceeded",
+  "project_spend_limit_exceeded", "usage_limit_reached", "usage_not_included", "context_length_exceeded",
+  "invalid_prompt", "invalid_api_key", "authentication_error", "permission_denied", "access_denied",
+  "cyber_policy", "bio_policy", "misalignment_policy_violation", "content_filter",
+]);
+const TRANSIENT_NETWORK = new Set([
+  "ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT", "EAI_AGAIN", "ENETUNREACH", "EHOSTUNREACH",
+  "UND_ERR_SOCKET", "UND_ERR_CONNECT_TIMEOUT", "UND_ERR_HEADERS_TIMEOUT", "UND_ERR_BODY_TIMEOUT",
+]);
+
+export interface RetryEvidence { reason: string; retryAt?: number }
+
+export function compactionRetryLimit(configured?: number): number {
+  return Math.max(0, Math.min(MAX_RETRIES, Math.floor(Number.isFinite(configured) ? configured! : MAX_RETRIES)));
+}
+
+function retryDeadline(headers: Headers): number | undefined {
+  const milliseconds = headers.get("retry-after-ms");
+  const seconds = headers.get("retry-after");
+  for (const [value, scale] of [[milliseconds, 1], [seconds, 1_000]] as const) {
+    if (value !== null && /^\d+(?:\.\d+)?$/.test(value.trim())) {
+      const ms = Number(value) * scale;
+      // Numeric overflow is still server advice beyond our cap, not an absent header.
+      return Date.now() + ms;
+    }
+  }
+  if (seconds !== null && !/^[+-]?[\d.]+$/.test(seconds.trim())) {
+    const date = Date.parse(seconds);
+    if (Number.isFinite(date)) return Math.max(Date.now(), date);
+  }
+  return undefined;
+}
+
+export async function waitForCompactionRetry(
+  evidence: RetryEvidence, retry: number, maxDelayMs: number | undefined, signal: AbortSignal,
+): Promise<void> {
+  signal.throwIfAborted();
+  // Pi's zero means no configured ceiling; V2 still enforces its own bounded wait.
+  const cap = maxDelayMs !== undefined && Number.isFinite(maxDelayMs) && maxDelayMs > 0
+    ? Math.min(maxDelayMs, MAX_RETRY_DELAY_MS) : MAX_RETRY_DELAY_MS;
+  const requested = evidence.retryAt === undefined ? undefined : Math.max(0, evidence.retryAt - Date.now());
+  if (requested !== undefined && requested > cap) {
+    throw new Error(`Remote compaction retry delay exceeds the allowed maximum of ${cap}ms (${evidence.reason})`);
+  }
+  await delay(requested ?? Math.min(500 * 2 ** retry, cap), undefined, { signal });
+  signal.throwIfAborted();
+}
+
+function networkFailure(error: unknown): boolean {
+  const visited = new Set<unknown>();
+  for (let current = error; isObject(current) && !visited.has(current); current = current.cause) {
+    visited.add(current);
+    if (typeof current.code === "string" && TRANSIENT_NETWORK.has(current.code)) return true;
+  }
+  return false;
+}
+
+function classifyError(value: unknown): { code?: string; permanent: boolean; invalid: boolean; message?: string } {
+  if (!isObject(value)) return { permanent: false, invalid: true };
+  const records = [value, ...(isObject(value.error) ? [value.error] : [])];
+  let invalid = value.error !== undefined && !isObject(value.error);
+  const codes: string[] = [];
+  for (const record of records) {
+    if (record.code !== undefined) {
+      if (typeof record.code === "string" && record.code) codes.push(record.code);
+      else invalid = true;
+    } else if (typeof record.type === "string" && record.type !== "error" &&
+        !record.type.startsWith("response.")) codes.push(record.type);
+  }
+  const unique = [...new Set(codes)];
+  return {
+    code: unique.length === 1 ? unique[0] : undefined,
+    permanent: codes.some((code) => PERMANENT_CODES.has(code)),
+    invalid: invalid || unique.length > 1,
+    message: records.map((record) => record.message).find((message): message is string => typeof message === "string"),
+  };
+}
+
+function rateLimitDeadline(code: string, message: string | undefined): number | undefined {
+  // Codex interprets this advice only for explicit rate-limit codes, never arbitrary error prose.
+  if (code !== "rate_limit_exceeded" && code !== "slow_down") return undefined;
+  const match = message?.match(/\btry again in\s+(\d+(?:\.\d+)?)\s*(ms|seconds?|s)\b/i);
+  if (!match) return undefined;
+  const ms = Number(match[1]) * (match[2].toLowerCase() === "ms" ? 1 : 1_000);
+  return Date.now() + ms;
+}
+
+/** Observe framing independently: OpenAI's SDK intercepts some SSE error frames before Pi's raw hook. */
+class SseEvidenceObserver {
+  private line = "";
+  private data: string[] = [];
+  private size = 0;
+  private event = "";
+  private skipLf = false;
+  private oversized = false;
+  constructor(private readonly attempt: CompactionAttempt) {}
+  feed(text: string): void {
+    if (this.oversized) return;
+    for (const char of text) {
+      if (this.skipLf && char === "\n") { this.skipLf = false; continue; }
+      this.skipLf = false;
+      if (char === "\r" || char === "\n") {
+        this.finishLine();
+        this.skipLf = char === "\r";
+      } else if (!this.oversized) {
+        this.size += char.length;
+        if (this.size > MAX_OBSERVED_EVENT_CHARS) {
+          this.oversized = true;
+          this.line = "";
+          this.data = [];
+          this.attempt.blockRetry();
+          return;
+        } else this.line += char;
+      }
+    }
+  }
+  private finishLine(): void {
+    const line = this.line;
+    this.line = "";
+    if (this.oversized) return;
+    if (!line) {
+      if (this.data.length) {
+        const data = this.data.join("\n");
+        if (data.trim() === "[DONE]") this.attempt.blockRetry();
+        else {
+          try { this.attempt.observeEvent(JSON.parse(data), this.event); }
+          catch { this.attempt.blockRetry(); }
+        }
+      }
+      this.data = [];
+      this.event = "";
+      this.size = 0;
+    } else if (!line.startsWith(":")) {
+      const separator = line.indexOf(":");
+      const field = separator < 0 ? line : line.slice(0, separator);
+      const value = separator < 0 ? "" : line.slice(separator + 1).replace(/^ /, "");
+      if (field === "data") this.data.push(value);
+      if (field === "event") this.event = value;
+    }
+  }
+  finish(): void {
+    if (this.oversized) return;
+    if (this.line) this.finishLine();
+    if (this.data.length) {
+      // EOF can cut a valid response mid-frame. Still veto a complete permanent error at EOF.
+      try { this.attempt.observeEvent(JSON.parse(this.data.join("\n")), this.event); }
+      catch { /* Incomplete JSON at EOF is a truncated frame, unlike invalid JSON in a complete frame. */ }
+    }
+  }
+}
+
+export class CompactionAttempt {
+  private evidence?: RetryEvidence;
+  private blocked = false;
+  private terminal = false;
+  private progress = false;
+  private eof = false;
+  fatal?: { error: unknown };
+
+  blockRetry(error?: unknown): void {
+    this.blocked = true;
+    if (error !== undefined && !this.fatal) this.fatal = { error };
+  }
+  fetchFailed(error: unknown): void {
+    if (networkFailure(error)) this.evidence = { reason: "transient network failure" };
+  }
+  observeEvent(value: unknown, eventName?: string): Error | undefined {
+    if (!isObject(value)) { this.blockRetry(); return; }
+    const response = isObject(value.response) ? value.response : undefined;
+    if (eventName === "error" || value.type === "error" || isObject(value.error) || value.type === "response.failed") {
+      const error = classifyError(value.type === "response.failed" ? response?.error : value);
+      const code = error.code;
+      if (!error.invalid && !error.permanent && code && TRANSIENT_CODES.has(code)) {
+        this.evidence = { reason: `server error ${code}`, retryAt: rateLimitDeadline(code, error.message) };
+        return new Error(`Remote compaction failed temporarily (${code})`);
+      }
+      this.blockRetry();
+    }
+    if (typeof value.type !== "string") this.blockRetry();
+    if (value.type === "response.completed" || value.type === "response.done" ||
+        value.type === "response.incomplete" || value.type === "response.failed" || value.type === "response.cancelled") {
+      this.terminal = true;
+    }
+    if (value.type === "response.created" || value.type === "response.in_progress" ||
+        value.type === "response.output_item.added" || value.type === "response.output_item.done") this.progress = true;
+    return undefined;
+  }
+  retryEvidence(): RetryEvidence | undefined {
+    if (this.blocked || this.terminal) return undefined;
+    return this.evidence ?? (this.eof && this.progress ? { reason: "Responses stream ended before its terminal event" } : undefined);
+  }
+
+  observeResponse(response: Response, signal: AbortSignal): Response {
+    const isSse = response.ok && response.headers.get("content-type")?.toLowerCase().includes("text/event-stream");
+    if (!response.ok) {
+      if (TRANSIENT_HTTP.has(response.status) && response.headers.get("x-should-retry") !== "false") {
+        this.evidence = { reason: `HTTP ${response.status}`, retryAt: retryDeadline(response.headers) };
+      } else this.blockRetry();
+    }
+    if (!response.body || (response.ok && !isSse)) return response;
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const sse = isSse ? new SseEvidenceObserver(this) : undefined;
+    let errorBody = "";
+    let errorBodyTooLarge = false;
+    let closed = false;
+    let abort: () => void;
+    const cleanup = () => { closed = true; signal.removeEventListener("abort", abort); };
+    const inspect = (text: string) => {
+      if (sse) sse.feed(text);
+      else if (!errorBodyTooLarge) {
+        if (errorBody.length + text.length > MAX_OBSERVED_EVENT_CHARS) {
+          errorBodyTooLarge = true;
+          errorBody = "";
+          this.blockRetry();
+        } else errorBody += text;
+      }
+    };
+    const body = new ReadableStream<Uint8Array>({
+      start(controller) {
+        abort = () => {
+          if (closed) return;
+          cleanup();
+          controller.error(signal.reason);
+          void reader.cancel(signal.reason).finally(() => reader.releaseLock()).catch(() => {});
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        if (signal.aborted) abort();
+      },
+      pull: async (controller) => {
+        try {
+          const result = await reader.read();
+          if (closed) return;
+          if (result.done) {
+            inspect(decoder.decode());
+            sse?.finish();
+            if (!sse && !errorBodyTooLarge) {
+              try {
+                const error = classifyError(JSON.parse(errorBody));
+                if (error.permanent || error.invalid || (error.code && !TRANSIENT_CODES.has(error.code))) this.blockRetry();
+              } catch { /* A transient HTTP status can legitimately carry a non-JSON gateway error. */ }
+            }
+            this.eof = Boolean(sse);
+            cleanup();
+            reader.releaseLock();
+            controller.close();
+          } else {
+            inspect(decoder.decode(result.value, { stream: true }));
+            controller.enqueue(result.value);
+          }
+        } catch (error) {
+          if (closed) return;
+          this.fetchFailed(error);
+          cleanup();
+          reader.releaseLock();
+          controller.error(error);
+        }
+      },
+      cancel(reason) {
+        if (closed) return;
+        cleanup();
+        return reader.cancel(reason).finally(() => reader.releaseLock());
+      },
+    }, { highWaterMark: 0 });
+    return new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+  }
+}

package/src/remote.ts

@@ -6,12 +6,12 @@ import { capableModel, deriveEndpoint, normalizeUrl, sameBackend, sameModel, typ
 import { trimToolOutputsToContextWindow } from "./context-window.js";
 import { estimateImages, type ImageEstimates } from "./image-budget.js";
 import { contextUserItems, type UserItemOrigin } from "./retention-input.js";
-import { CodexCompactionProtocolError, createCompactionCollector, isObject, type JsonObject, prepareRemoteCompactionPayload } from "./protocol.js";
+import { CodexCompactionProtocolError, createCompactionCollector, isObject, type JsonObject, prepareRemoteCompactionPayload, withoutInputImages } from "./protocol.js";
 import { applyProviderRequest, type ProviderRequestSnapshot } from "./request-snapshot.js";
+import { CompactionAttempt, compactionRetryLimit, waitForCompactionRetry } from "./remote-retry.js";
 
 const REMOTE_COMPACTION_FEATURE = "remote_compaction_v2";
 const REQUEST_TIMEOUT_MS = 300_000;
-const MAX_RETRIES = 2;
 const MISSING_PAYLOAD_MESSAGE = "Provider did not expose a request payload";
 
 export interface RemoteCompactionRequest {
@@ -21,6 +21,8 @@ export interface RemoteCompactionRequest {
   reasoning: ThinkingLevel;
   sessionId: string;
   thinkingBudgets?: ThinkingBudgets;
+  /** Apply the current Pi image policy to both fresh input and replayed opaque checkpoint history. */
+  blockImages?: boolean;
   /** Pi's provider retry setting; Codex caps compaction retries below it. */
   maxRetries?: number;
   maxRetryDelayMs?: number;
@@ -63,81 +65,152 @@ function objectItems(input: unknown): JsonObject[] {
 
 export async function requestRemoteCompaction(request: RemoteCompactionRequest): Promise<RemoteCompactionResponse> {
   request.signal.throwIfAborted();
-  const configured = capableModel(request.model);
+  const model = structuredClone(request.model);
+  const context = structuredClone(request.context);
+  const configured = capableModel(model);
   if (!configured) throw new CodexCompactionProtocolError("Model is not configured for remote compaction");
-  const collector = createCompactionCollector();
+  const retries = compactionRetryLimit(request.maxRetries);
+  let preparedPayload: JsonObject | undefined;
   let sentInput: JsonObject[] | undefined;
   let identity: ProviderIdentity | undefined;
-  let usage: Usage | undefined;
   let images: ImageEstimates | undefined;
   let contextual: boolean[] | undefined;
   const baseFetch = request.fetch ?? globalThis.fetch;
-  const routedFetch: typeof globalThis.fetch = async (input, init) => {
-    if (!identity) throw new CodexCompactionProtocolError(MISSING_PAYLOAD_MESSAGE);
-    const actual = normalizeUrl(input instanceof Request ? input.url : String(input));
-    const defaultEndpoint = deriveEndpoint(identity.baseUrl, identity.api);
-    if (actual !== defaultEndpoint && actual !== identity.endpoint) {
-      throw new CodexCompactionProtocolError(`Provider requested unexpected compaction endpoint ${actual}`);
-    }
-    const method = init?.method ?? (input instanceof Request ? input.method : "GET");
-    if (method.toUpperCase() !== "POST") throw new CodexCompactionProtocolError("Remote compaction request must use POST");
-    if (actual === identity.endpoint) return baseFetch(input, init);
-    // Endpoint overrides are same-origin HTTP routes; authentication remains assembled by Pi.
-    return input instanceof Request
-      ? baseFetch(new Request(identity.endpoint, new Request(input, init)))
-      : baseFetch(identity.endpoint, init);
-  };
-  const stream = request.modelRegistry.streamSimple(request.model, request.context, {
-    signal: request.signal,
-    // Pi pools WebSockets without comparing handshake headers; V2 needs its feature header on every request.
-    transport: "sse",
-    reasoning: request.reasoning === "off" ? undefined : request.reasoning,
-    thinkingBudgets: request.thinkingBudgets,
-    sessionId: request.sessionId,
-    timeoutMs: REQUEST_TIMEOUT_MS,
-    maxRetries: Math.min(request.maxRetries ?? MAX_RETRIES, MAX_RETRIES),
-    maxRetryDelayMs: request.maxRetryDelayMs,
-    transformHeaders: mergeRemoteCompactionHeader,
-    fetch: routedFetch,
-    onPayload: async (payload, preparedModel) => {
-      if (!sameModel(configured.identity, preparedModel)) {
-        throw new CodexCompactionProtocolError("Provider resolved an unexpected compaction model");
+  for (let retry = 0; ; retry++) {
+    request.signal.throwIfAborted();
+    const attempt = new CompactionAttempt();
+    const collector = createCompactionCollector();
+    let usage: Usage | undefined;
+    let compactionCount = 0;
+    let fetched = false;
+    const routedFetch: typeof globalThis.fetch = async (input, init) => {
+      try {
+        request.signal.throwIfAborted();
+        if (!identity) throw new CodexCompactionProtocolError(MISSING_PAYLOAD_MESSAGE);
+        const actual = normalizeUrl(input instanceof Request ? input.url : String(input));
+        const defaultEndpoint = deriveEndpoint(identity.baseUrl, identity.api);
+        if (actual !== defaultEndpoint && actual !== identity.endpoint) {
+          throw new CodexCompactionProtocolError(`Provider requested unexpected compaction endpoint ${actual}`);
+        }
+        const method = init?.method ?? (input instanceof Request ? input.method : "GET");
+        if (method.toUpperCase() !== "POST") throw new CodexCompactionProtocolError("Remote compaction request must use POST");
+        if (fetched) throw new CodexCompactionProtocolError("Provider exceeded the single-request compaction attempt budget");
+        fetched = true;
+      } catch (error) {
+        attempt.blockRetry(error);
+        throw error;
       }
-      const resolved = capableModel(request.model, preparedModel.baseUrl);
-      if (!resolved) throw new CodexCompactionProtocolError("Resolved provider endpoint is incompatible with remote compaction");
-      identity = resolved.identity;
-      const prior = request.priorCheckpoint?.identity;
-      if (prior && !sameBackend(prior, identity)) {
-        throw new CodexCompactionProtocolError("The active opaque checkpoint belongs to a different resolved provider backend");
+      try {
+        // Endpoint overrides are same-origin HTTP routes; authentication remains assembled by Pi.
+        const actual = normalizeUrl(input instanceof Request ? input.url : String(input));
+        const response = actual === identity!.endpoint ? await baseFetch(input, init)
+          : input instanceof Request
+            ? await baseFetch(new Request(identity!.endpoint, new Request(input, init)))
+            : await baseFetch(identity!.endpoint, init);
+        return attempt.observeResponse(response, request.signal);
+      } catch (error) {
+        attempt.fetchFailed(error);
+        throw error;
+      }
+    };
+    try {
+      const stream = request.modelRegistry.streamSimple(model, structuredClone(context), {
+        signal: request.signal,
+        // Pi pools WebSockets without comparing handshake headers; V2 needs its feature header on every request.
+        transport: "sse",
+        reasoning: request.reasoning === "off" ? undefined : request.reasoning,
+        thinkingBudgets: request.thinkingBudgets,
+        sessionId: request.sessionId,
+        timeoutMs: REQUEST_TIMEOUT_MS,
+        // Only the outer V2 loop retries; provider HTTP retries would multiply the global budget.
+        maxRetries: 0,
+        maxRetryDelayMs: request.maxRetryDelayMs,
+        transformHeaders: mergeRemoteCompactionHeader,
+        fetch: routedFetch,
+        onPayload: async (payload, preparedModel) => {
+          try {
+            request.signal.throwIfAborted();
+            if (!sameModel(configured.identity, preparedModel)) {
+              throw new CodexCompactionProtocolError("Provider resolved an unexpected compaction model");
+            }
+            const resolved = capableModel(model, preparedModel.baseUrl);
+            if (!resolved) throw new CodexCompactionProtocolError("Resolved provider endpoint is incompatible with remote compaction");
+            if (identity && !sameBackend(identity, resolved.identity)) {
+              throw new CodexCompactionProtocolError("Resolved provider backend changed during remote compaction retries");
+            }
+            identity = resolved.identity;
+            const prior = request.priorCheckpoint?.identity;
+            if (prior && !sameBackend(prior, identity)) {
+              throw new CodexCompactionProtocolError("The active opaque checkpoint belongs to a different resolved provider backend");
+            }
+            if (preparedPayload) {
+              if (!isObject(payload) || payload.model !== model.id) {
+                throw new CodexCompactionProtocolError("Provider payload used an unexpected model");
+              }
+              // Re-authenticate each attempt, but never let a new serialization change the compacted input.
+              request.onPrepared?.();
+              return structuredClone(preparedPayload);
+            }
+            if (!isObject(payload)) throw new CodexCompactionProtocolError("Prepared compaction payload must be an object");
+            const applied = applyProviderRequest(payload, resolved, request.providerRequest,
+              contextUserItems(payload.input, request.userItemOrigins));
+            const adapted = request.blockImages
+              ? { ...applied.payload, input: withoutInputImages(objectItems(applied.payload.input)) } : applied.payload;
+            const checkpoint = request.priorCheckpoint && request.blockImages
+              ? { ...request.priorCheckpoint, replacementHistory: withoutInputImages(request.priorCheckpoint.replacementHistory) }
+              : request.priorCheckpoint;
+            const payloadItems = objectItems(adapted.input);
+            const contextItems = new Set(payloadItems.filter((_, index) => applied.contextual[index]));
+            const estimates = await estimateImages([...payloadItems, ...checkpoint?.replacementHistory ?? []], request.signal);
+            const prepared = prepareRemoteCompactionPayload(adapted, checkpoint, (history) => ({
+              ...history,
+              input: trimToolOutputsToContextWindow(objectItems(history.input), history.instructions, preparedModel.contextWindow, estimates),
+            }));
+            if (prepared.model !== model.id) throw new CodexCompactionProtocolError("Provider payload used an unexpected model");
+            const sent = objectItems(prepared.input).slice(0, -1);
+            contextual = sent.map((item) => contextItems.has(item));
+            sentInput = structuredClone(sent);
+            images = estimates;
+            preparedPayload = structuredClone(prepared);
+            request.onPrepared?.();
+            return prepared;
+          } catch (error) {
+            attempt.blockRetry(error);
+            throw error;
+          }
+        },
+        onProviderStreamEvent: (event) => {
+          request.signal.throwIfAborted();
+          const transient = attempt.observeEvent(event);
+          if (transient) throw transient;
+          try {
+            if (isObject(event) && event.type === "response.output_item.done" && isObject(event.item) &&
+                (event.item.type === "compaction" || event.item.type === "compaction_summary") && ++compactionCount > 1) {
+              throw new CodexCompactionProtocolError("Remote compaction returned duplicate compaction output events");
+            }
+            collector.observe(event);
+          } catch (error) {
+            attempt.blockRetry(error);
+            throw error;
+          }
+        },
+      });
+      for await (const event of stream) {
+        request.signal.throwIfAborted();
+        if (event.type === "error") throw new Error(event.error.errorMessage ?? "Codex compaction request failed");
+        if (event.type === "done") usage = event.message.usage;
       }
-      if (isObject(payload)) payload = applyProviderRequest(payload, resolved, request.providerRequest);
-      const contextItems = contextUserItems(isObject(payload) ? payload.input : undefined, request.userItemOrigins);
-      const payloadItems = isObject(payload) && Array.isArray(payload.input) ? payload.input.filter(isObject) : [];
-      const estimates = await estimateImages([...payloadItems, ...request.priorCheckpoint?.replacementHistory ?? []], request.signal);
-      const prepared = prepareRemoteCompactionPayload(payload, request.priorCheckpoint, (history) => ({
-        ...history,
-        input: trimToolOutputsToContextWindow(objectItems(history.input), history.instructions, request.model.contextWindow, estimates),
-      }));
-      if (prepared.model !== request.model.id) throw new CodexCompactionProtocolError("Provider payload used an unexpected model");
-      const sent = objectItems(prepared.input).slice(0, -1);
-      contextual = sent.map((item) => contextItems.has(item));
-      sentInput = structuredClone(sent);
-      images = estimates;
-      request.onPrepared?.();
-      return prepared;
-    },
-    onProviderStreamEvent: (event) => {
       request.signal.throwIfAborted();
-      collector.observe(event);
-    },
-  });
-  for await (const event of stream) {
-    request.signal.throwIfAborted();
-    if (event.type === "error") throw new Error(event.error.errorMessage ?? "Codex compaction request failed");
-    if (event.type === "done") usage = event.message.usage;
+      if (attempt.fatal) throw attempt.fatal.error;
+      if (!sentInput || !identity || !images || !contextual) throw new CodexCompactionProtocolError(MISSING_PAYLOAD_MESSAGE);
+      if (!usage) throw new CodexCompactionProtocolError("Provider stream ended without a completed message");
+      return { item: collector.finish(), promptInput: sentInput, identity, usage, images, contextual };
+    } catch (error) {
+      request.signal.throwIfAborted();
+      if (attempt.fatal) throw attempt.fatal.error;
+      const evidence = attempt.retryEvidence();
+      if (!evidence || retry >= retries) throw error;
+      await waitForCompactionRetry(evidence, retry, request.maxRetryDelayMs, request.signal);
+    }
   }
-  request.signal.throwIfAborted();
-  if (!sentInput || !identity || !images || !contextual) throw new CodexCompactionProtocolError(MISSING_PAYLOAD_MESSAGE);
-  if (!usage) throw new CodexCompactionProtocolError("Provider stream ended without a completed message");
-  return { item: collector.finish(), promptInput: sentInput, identity, usage, images, contextual };
 }