@@ -24,7 +24,7 @@ import {
   updateReasoningReplayServingIdentity,
 } from "../../responses/reasoning-replay-cache";
 import { awaitThoughtSignatureDurability, thoughtSignatureReplaySalt } from "../../responses/thought-signature-replay";
-import { buildCompactV1Output, COMPACT_PROMPT, compactionItemToText, decodeCompactionSummary, extractCompactUserMessages, isCompactionItemType } from "../../responses/compaction";
+import { buildCompactV1Output, COMPACT_PROMPT, decodeCompactionSummary, extractCompactUserMessages } from "../../responses/compaction";
 import { FORWARD_HEADERS, sanitizeReasoningInputContent } from "../../adapters/openai-responses";
 import {
   expandPreviousResponseInput,
@@ -516,27 +516,50 @@ async function opaqueBlobRejectionBodyForRecovery(
 
 function prepareOpaqueBlobRecovery(parsed: OcxParsedRequest): void {
   parsed._stripReasoningEncryptedContent = true;
-  const body = parsed._rawBody;
-  if (!body || typeof body !== "object" || Array.isArray(body)) return;
-  const input = (body as { input?: unknown }).input;
-  if (!Array.isArray(input)) return;
-  let changed = false;
-  const recoveredInput = input.map(item => {
-    if (!item || typeof item !== "object" || Array.isArray(item)) return item;
-    const candidate = item as { type?: unknown; encrypted_content?: unknown };
-    if (!isCompactionItemType(candidate.type) || typeof candidate.encrypted_content !== "string") {
-      return item;
-    }
-    changed = true;
-    return {
-      type: "message",
-      role: "user",
-      content: [{ type: "input_text", text: compactionItemToText(candidate.encrypted_content) }],
-    };
-  });
-  // Mutate only the raw input carrier so the adapter rebuild sees the same degradation as its
-  // ordinary compaction scrub. Keeping the body object preserves non-enumerable persistence marks.
-  if (changed) (body as { input: unknown[] }).input = recoveredInput;
+}
+
+type OpaqueBlobRecoveryGuard = { attempted: boolean };
+
+type OpaqueBlobRecoveryResult =
+  | { kind: "skipped" }
+  | { kind: "recovered"; response: Response }
+  | { kind: "failed"; response: Response };
+
+async function attemptOpaqueBlobRecovery(
+  args: {
+    response: Response;
+    outboundBody?: string;
+    adapterName: string;
+    parsed: OcxParsedRequest;
+    guard: OpaqueBlobRecoveryGuard;
+    signal: AbortSignal;
+  },
+  rebuild: (kind: AttemptRecoveryKind) => Promise<Response | { failed: Response }>,
+): Promise<OpaqueBlobRecoveryResult> {
+  const errorBody = await opaqueBlobRejectionBodyForRecovery(
+    args.response,
+    args.outboundBody,
+    args.adapterName,
+    args.guard.attempted,
+    args.signal,
+  );
+  if (errorBody === undefined || !shouldAttemptOpaqueBlobRecovery({
+    status: args.response.status,
+    adapterName: args.adapterName,
+    outboundBody: args.outboundBody,
+    errorBody,
+    alreadyAttempted: args.guard.attempted,
+  })) {
+    return { kind: "skipped" };
+  }
+
+  args.guard.attempted = true;
+  prepareOpaqueBlobRecovery(args.parsed);
+  try { void args.response.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
+  const result = await rebuild("opaque-blob-rejection");
+  return "failed" in result
+    ? { kind: "failed", response: result.failed }
+    : { kind: "recovered", response: result };
 }
 
 function nonEmptyProviderApiKey(provider: OcxProviderConfig): string | undefined {
@@ -2875,7 +2898,7 @@ async function handleResponsesInner(
       request.releaseBodyObservation?.();
     }
 
-    let opaqueBlobRecoveryAttempted = false;
+    const opaqueBlobRecoveryGuard: OpaqueBlobRecoveryGuard = { attempted: false };
     let oauth401ReplayAttempted = false;
     const rateLimitPolicy = rateLimitRetryPolicyFor(route.provider);
     let rateLimitRetries = 0;
@@ -2943,6 +2966,7 @@ async function handleResponsesInner(
       }
     };
 
+    // Keep recovery kinds in sync with the generic `recovery:` loop below.
     passthroughRecovery: for (;;) {
 
     // Native Responses providers return before the generic adapter recovery loop below. Keep
@@ -3150,33 +3174,24 @@ async function handleResponsesInner(
     // eviction, or an older transcript). Inspect only a bounded clone of a 4xx whose exact outbound
     // Responses body still carries opaque state, then rebuild once through the ordinary adapter
     // sanitation path. A second rejection falls through unchanged because the guard stays armed.
-    const opaqueBlobErrorBody = await opaqueBlobRejectionBodyForRecovery(
-      upstreamResponse,
-      request.body,
-      adapter.name,
-      opaqueBlobRecoveryAttempted,
-      upstream.signal,
-    );
-    if (opaqueBlobErrorBody !== undefined && shouldAttemptOpaqueBlobRecovery({
-      status: upstreamResponse.status,
-      adapterName: adapter.name,
+    const opaqueBlobRecovery = await attemptOpaqueBlobRecovery({
+      response: upstreamResponse,
       outboundBody: request.body,
-      errorBody: opaqueBlobErrorBody,
-      alreadyAttempted: opaqueBlobRecoveryAttempted,
-    })) {
-      opaqueBlobRecoveryAttempted = true;
-      prepareOpaqueBlobRecovery(parsed);
-      try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
-      const result = await rebuildAndRefetch("opaque-blob-rejection");
-      if ("failed" in result) return result.failed;
-      upstreamResponse = result;
+      adapterName: adapter.name,
+      parsed,
+      guard: opaqueBlobRecoveryGuard,
+      signal: upstream.signal,
+    }, rebuildAndRefetch);
+    if (opaqueBlobRecovery.kind === "failed") return opaqueBlobRecovery.response;
+    if (opaqueBlobRecovery.kind === "recovered") {
+      upstreamResponse = opaqueBlobRecovery.response;
       continue passthroughRecovery;
     }
     break;
     }
     // Binding normally records before the first send. Repeat it only after a successful recovery
     // so an eviction during the extra round trip cannot leave the next cross-route turn cold.
-    if (opaqueBlobRecoveryAttempted && upstreamResponse.ok) {
+    if (opaqueBlobRecoveryGuard.attempted && upstreamResponse.ok) {
       updateReasoningReplayServingIdentity(parsed._reasoningReplayScope);
     }
     const headers = sanitizePassthroughHeaders(upstreamResponse.headers);
@@ -4243,7 +4258,7 @@ async function handleResponsesInner(
     // adapter, and imageTierBias — once armed — rides EVERY subsequent rebuild so a
     // 413→429 rotation cannot silently undo the tightening.
     let imageRetryAttempted = false;
-    let opaqueBlobRecoveryAttempted = false;
+    const opaqueBlobRecoveryGuard: OpaqueBlobRecoveryGuard = { attempted: false };
     let oauth401ReplayAttempted = false;
     /**
      * Rebuild the request from the current parsed input (and any image-tier bias) and refetch
@@ -4321,6 +4336,7 @@ async function handleResponsesInner(
         return { failed: formatErrorResponse(502, "upstream_error", msg) };
       }
     };
+    // Keep recovery kinds in sync with the native Responses `passthroughRecovery:` loop above.
     recovery: for (;;) {
       if (
         upstreamResponse.status === 401
@@ -4481,27 +4497,20 @@ async function handleResponsesInner(
       // the missing authoritative signal. Rebuild once through the same sanitation path used by a
       // known route switch; invalidating is mandatory because `parsed` mutates in place and the
       // same-target cache would otherwise replay the rejected bytes verbatim.
-      const opaqueBlobErrorBody = await opaqueBlobRejectionBodyForRecovery(
-        upstreamResponse,
-        sameTargetRequest?.body,
-        activeAdapter.name,
-        opaqueBlobRecoveryAttempted,
-        upstream.signal,
-      );
-      if (opaqueBlobErrorBody !== undefined && shouldAttemptOpaqueBlobRecovery({
-        status: upstreamResponse.status,
-        adapterName: activeAdapter.name,
+      const opaqueBlobRecovery = await attemptOpaqueBlobRecovery({
+        response: upstreamResponse,
         outboundBody: sameTargetRequest?.body,
-        errorBody: opaqueBlobErrorBody,
-        alreadyAttempted: opaqueBlobRecoveryAttempted,
-      })) {
-        opaqueBlobRecoveryAttempted = true;
-        prepareOpaqueBlobRecovery(parsed);
+        adapterName: activeAdapter.name,
+        parsed,
+        guard: opaqueBlobRecoveryGuard,
+        signal: upstream.signal,
+      }, recovery => {
         invalidateSameTargetRequest();
-        try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
-        const result = await rebuildAndRefetch("opaque-blob-rejection");
-        if ("failed" in result) return result.failed;
-        upstreamResponse = result;
+        return rebuildAndRefetch(recovery);
+      });
+      if (opaqueBlobRecovery.kind === "failed") return opaqueBlobRecovery.response;
+      if (opaqueBlobRecovery.kind === "recovered") {
+        upstreamResponse = opaqueBlobRecovery.response;
         continue recovery;
       }
       // Anthropic 413 request_too_large: rebuild once with every image one tier lower
@@ -4525,7 +4534,7 @@ async function handleResponsesInner(
     }
     // Binding normally records before the first send. Repeat it only after a successful recovery
     // so an eviction during the extra round trip cannot leave the next cross-route turn cold.
-    if (opaqueBlobRecoveryAttempted && upstreamResponse.ok) {
+    if (opaqueBlobRecoveryGuard.attempted && upstreamResponse.ok) {
       updateReasoningReplayServingIdentity(parsed._reasoningReplayScope);
     }
     if (!upstreamResponse.ok) {
 
@@ -202,6 +202,43 @@ describe("opaque blob recovery through /v1/responses", () => {
     expect(logCtx.activeAttempt?.recoveryKinds).toEqual(["opaque-blob-rejection"]);
   });
 
+  test("degrades a compaction blob through the generic routed-compaction recovery resend", async () => {
+    const outbound: Array<Record<string, unknown>> = [];
+    globalThis.fetch = (async (_input: RequestInfo | URL, init?: RequestInit) => {
+      outbound.push(JSON.parse(String(init?.body)) as Record<string, unknown>);
+      return outbound.length === 1 ? rejection(XAI_DECODE_ERROR) : success("resp-compact-recovered");
+    }) as typeof fetch;
+    const body = {
+      model: "first/model-a",
+      stream: false,
+      store: false,
+      input: [...reasoningReplayInput(), { type: "compaction_trigger" }],
+    };
+    const logCtx: RequestLogContext = { model: "", provider: "" };
+
+    const response = await handleResponses(new Request("http://localhost/v1/responses", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-codex-parent-thread-id": "thread-routed-compaction-recovery",
+      },
+      body: JSON.stringify(body),
+    }), config(), logCtx);
+    expect(response.status).toBe(200);
+    await response.text();
+
+    expect(outbound).toHaveLength(2);
+    expect(hasBlob(outbound[0]!)).toBe(true);
+    expect(hasBlob(outbound[1]!)).toBe(false);
+    expect(outbound[1]!.input).toContainEqual({
+      type: "message",
+      role: "user",
+      content: [{ type: "input_text", text: OPAQUE_COMPACTION_NOTE }],
+    });
+    expect(logCtx.activeAttempt?.sendCount).toBe(2);
+    expect(logCtx.activeAttempt?.recoveryKinds).toEqual(["opaque-blob-rejection"]);
+  });
+
   test("surfaces the second rejection after exactly one recovery attempt", async () => {
     let upstreamCalls = 0;
     globalThis.fetch = (async () => {