@bitkyc08/opencodex 2.7.35 → 2.7.36

package/src/server/responses/collaboration.ts

@@ -0,0 +1,300 @@
+import type { Server } from "bun";
+import { bridgeToResponsesSSE, buildResponseJSON, formatErrorResponse, type ResponsesTerminalStatus } from "../../bridge";
+import {
+  getConfigPath,
+  multiAgentGuidanceEnabled,
+  resolveEnvValue,
+} from "../../config";
+import { parseRequest } from "../../responses/parser";
+import { buildCompactV1Output, COMPACT_PROMPT, decodeCompactionSummary, extractCompactUserMessages } from "../../responses/compaction";
+import { FORWARD_HEADERS, sanitizeReasoningInputContent } from "../../adapters/openai-responses";
+import { expandPreviousResponseInput, previousResponseProviderState, rememberResponseState } from "../../responses/state";
+import { routeModel } from "../../router";
+import {
+  advanceComboAfterFailure,
+  comboDefaultEffort,
+  comboFailureDecision,
+  comboIdFromRawBody,
+  concreteComboRequestBody,
+  getCombo,
+  isComboTargetInCooldown,
+  NoAvailableComboTargetsError,
+  noteComboSuccess,
+  parseRetryAfterMs,
+  pickComboTarget,
+  targetKey,
+} from "../../combos";
+import { isInjectionDebugEnabled } from "../../lib/debug-settings";
+import { injectionDebugLog } from "../../lib/injection-debug-log";
+import { modelInList, namespacedToolName } from "../../types";
+import type { AdapterEvent, OcxConfig, OcxParsedRequest, OcxProviderConfig, OcxProviderContinuationState, OcxUsage } from "../../types";
+import {
+  forceRefreshOAuthAccessSnapshot,
+  getOAuthCredentialApiBaseUrl,
+  getOAuthCredentialProjectId,
+  getValidAccessTokenSnapshot,
+  type OAuthAccessSnapshot,
+  UnsupportedOAuthProviderError,
+} from "../../oauth";
+import { buildWebSearchTool, planWebSearch, runWithWebSearch, shouldResolveOpenAiWebSearchSidecar } from "../../web-search";
+import { describeImagesInPlace, planVisionSidecar, shouldResolveOpenAiVisionSidecar, stripImagesInPlace } from "../../vision";
+import { createAdapterEventQueue, preflightAdapterEvents } from "../../adapters/run-turn-queue";
+import {
+  applyCodexAuthContextToProvider,
+  CodexAccountCooldownError,
+  CodexAuthContextError,
+  CodexDirectAuthenticationError,
+  CodexPoolAuthenticationError,
+  CodexThreadAffinityExpiredError,
+  headersForCodexAuthContext,
+  isCodexAuthContextUsable,
+  resolveCodexAuthContext,
+  type CodexAuthContext,
+} from "../../codex/auth-context";
+import {
+  formatCodexProviderForLog,
+  recordCodexUpstreamOutcome,
+  type CodexUpstreamOutcome,
+} from "../../codex/routing";
+import { fetchWithResetRetry, fetchWithTransientRetry, applyUpstreamRecoveryInit } from "../../lib/upstream-retry";
+import { ForwardAdmissionCredentialError, validateForwardAdmissionCredential } from "../auth-cors";
+import { listOpenAiForwardSidecarCandidates, resolveFirstUsableOpenAiSidecar, type ResolvedOpenAiForwardSidecar } from "../../providers/openai-sidecar";
+import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers";
+import { slugsEquivalent } from "../../providers/slug-codec";
+import { applyOpenAiVirtualModel, resolveOpenAiCompactModel } from "../../providers/openai-virtual-models";
+import { isUsageDebugEnabled } from "../../usage/debug";
+import { readJsonRequestBody, DecompressedBodyTooLargeError, UnsupportedContentEncodingError } from "../request-decompress";
+import { resolveAdapter, resolveWireProtocolOverride } from "../adapter-resolve";
+import { hasKeyPoolFailover, rotateProviderTransportOn429 } from "../../providers/key-failover";
+import { shouldAttemptImageTierRetry } from "../image-retry";
+import { resolveProviderTransport } from "../../providers/xai-transport";
+import type { WsData } from "../ws-bridge";
+import { registerTurn, trackStreamLifetime, unregisterTurn } from "../lifecycle";
+import { redactSecretString } from "../../lib/redact";
+import { readBoundedResponseBody } from "../../lib/bounded-body";
+import { supportedLadderFor } from "../effort-policy";
+import {
+  beginRequestAttempt,
+  catalogModelSupportsServiceTier,
+  finishRequestAttempt,
+  inspectResponseLogJson,
+  noteAttemptSend,
+  readConfiguredCodexServiceTier,
+  requestLogSpeedLabel,
+  sealRequestAttemptIdentity,
+  usageFromResponsesPayload,
+  type RequestLogContext,
+} from "../request-log";
+import type { AttemptRecoveryKind } from "../../usage/log";
+import {
+  consumeForInspection,
+  consumeForResponseLogMetadata,
+  markNativePassthroughSseResponse,
+  relaySseWithFailedTail,
+  relayWithAbort,
+  sanitizePassthroughHeaders,
+} from "../relay";
+import { hasResponsesItemIdRepair, relaySseWithResponsesItemIdRepair } from "../responses-item-id-repair";
+import type { EffectiveSubagentRoster, SpawnAgentSurface } from "../../codex/catalog";
+
+
+export function buildToolBridgeMaps(parsed: OcxParsedRequest): {
+  toolNsMap: Map<string, { namespace: string; name: string }>;
+  freeformToolNames: Set<string>;
+  toolSearchToolNames: Set<string>;
+} {
+  const toolNsMap = new Map<string, { namespace: string; name: string }>();
+  const freeformToolNames = new Set<string>();
+  const toolSearchToolNames = new Set<string>();
+  for (const t of parsed.context.tools ?? []) {
+    if (t.namespace) toolNsMap.set(namespacedToolName(t.namespace, t.name), { namespace: t.namespace, name: t.name });
+    if (t.freeform) freeformToolNames.add(t.name);
+    if (t.toolSearch) toolSearchToolNames.add(t.name);
+  }
+  return { toolNsMap, freeformToolNames, toolSearchToolNames };
+}
+
+
+
+export const PROACTIVE_MULTI_AGENT_MODE_TEXT = [
+  "Proactive multi-agent delegation is active.",
+  "Any earlier instruction requiring an explicit user request before spawning sub-agents no longer applies.",
+  "Delegate independent sub-tasks to sub-agents whenever parallel work would materially improve speed or quality — do not serialize work that can run concurrently.",
+  "Each sub-agent runs in its own context and can use all available tools; prefer spawning specialists over doing everything yourself.",
+  "This mode remains active until a later multi-agent mode developer message changes it.",
+].join(" ");
+
+export function isV1CollabSurface(parsed: OcxParsedRequest): boolean {
+  return collabSurface(parsed) === "v1";
+}
+
+
+
+export function collabSurface(parsed: OcxParsedRequest): "v1" | "v2" | null {
+  let namespacedSpawn = false;
+  let flatSpawn = false;
+  let v1Only = false;
+  let v2Only = false;
+  for (const t of parsed.context.tools ?? []) {
+    if (t.name === "spawn_agent") {
+      if (t.namespace) namespacedSpawn = true;
+      else flatSpawn = true;
+    } else if (t.name === "send_input" || t.name === "resume_agent" || t.name === "close_agent") {
+      v1Only = true;
+    } else if (t.name === "send_message" || t.name === "followup_task" || t.name === "interrupt_agent" || t.name === "list_agents") {
+      v2Only = true;
+    }
+  }
+  if (!namespacedSpawn && !flatSpawn) return null; // no spawn_agent -> no collab surface
+  if (namespacedSpawn && flatSpawn) return null;   // contradictory spawn shapes
+  if (v1Only && v2Only) return null;               // contradictory companions
+  if (v1Only) return "v1";
+  if (v2Only) return "v2";
+  return namespacedSpawn ? "v1" : "v2"; // companionless fallbacks (legacy defaults)
+}
+
+
+
+export interface MultiAgentGuidanceOptions {
+  multiAgentGuidanceEnabled?: boolean;
+  injectionModel?: string;
+  injectionEffort?: string;
+  subagentModels?: string[];
+  injectionPrompt?: string;
+}
+
+
+
+export interface MultiAgentGuidanceDeps {
+  resolveEffectiveSubagentRoster?: (
+    configuredModels: readonly string[],
+    surface: SpawnAgentSurface,
+  ) => EffectiveSubagentRoster | Promise<EffectiveSubagentRoster>;
+}
+
+
+
+export async function resolveEffectiveSubagentRoster(
+  configuredModels: readonly string[],
+  surface: SpawnAgentSurface,
+): Promise<EffectiveSubagentRoster> {
+  const { effectiveSubagentRoster } = await import("../../codex/catalog");
+  return effectiveSubagentRoster(configuredModels, surface);
+}
+
+
+
+export async function multiAgentGuidanceText(
+  parsed: OcxParsedRequest,
+  options: MultiAgentGuidanceOptions = {},
+  deps: MultiAgentGuidanceDeps = {},
+): Promise<string | null> {
+  if (options.multiAgentGuidanceEnabled === false) return null;
+  const {
+    injectionModel,
+    injectionEffort,
+    subagentModels,
+    injectionPrompt,
+  } = options;
+  const surface = collabSurface(parsed);
+  if (surface === null) return null;
+
+  if (surface === "v2") {
+    // codex-rs supplies the Proactive text on v2; the proxy only adds model-designation
+    // guidance, and only when there is something concrete to designate: a configured
+    // injectionModel and/or a roster entry that resolves in the injected catalog.
+    const configuredForGuidance = [
+      ...(subagentModels ?? []),
+      ...(injectionModel ? [injectionModel] : []),
+    ];
+    const resolveRoster = deps.resolveEffectiveSubagentRoster ?? resolveEffectiveSubagentRoster;
+    const effective = await resolveRoster(configuredForGuidance, "v2");
+    const rosterModels = effective.advertised.filter(candidate =>
+      (subagentModels ?? []).some(model => slugsEquivalent(model, candidate.model))
+    );
+    const roster = subagentRosterText(rosterModels);
+    const preferred = injectionModel
+      ? effective.candidates.find(candidate => slugsEquivalent(injectionModel, candidate.model))
+      : undefined;
+
+    if (isInjectionDebugEnabled() && effective.excluded.length > 0) {
+      injectionDebugLog(`[opencodex] multi-agent guidance excluded: ${effective.excluded
+        .map(item => `${item.configured}:${item.reason}`)
+        .join(", ")}`);
+    }
+    if (!injectionModel && roster === "") return null;
+    if (injectionPrompt) {
+      return `<multi_agent_mode>${applyInjectionPlaceholders(injectionPrompt, injectionModel, injectionEffort, roster)}</multi_agent_mode>`;
+    }
+    if (!preferred && roster === "") return null;
+    let text = "When the active spawn_agent tool supports optional \"model\" or \"reasoning_effort\" overrides, "
+      + "use only models listed for this collaboration surface. "
+      + "When setting either override, set fork_turns to \"none\" "
+      + "(or a positive turn count such as \"3\"; full-history forks reject overrides) "
+      + "and make the task message self-contained.";
+    if (preferred) {
+      text += ` Preferred sub-agent: model "${preferred.model}"`
+        + (injectionEffort ? `, reasoning_effort "${injectionEffort}"` : "")
+        + " — use it unless the user names another.";
+    }
+    text += roster;
+    if (text.length > V2_GUIDANCE_CHAR_BUDGET) {
+      // Roster is the only unbounded part — drop it before breaking the budget.
+      text = text.slice(0, text.length - roster.length);
+    }
+    return `<multi_agent_mode>${text}</multi_agent_mode>`;
+  }
+
+  const effort = parsed.options.reasoning;
+  // v1 keeps only the upstream-parity behavior: Proactive text at the top tier
+  // (ultra arrives as max on the wire). No designation/roster payload here.
+  if (effort !== "max" && effort !== "ultra") return null;
+  return `<multi_agent_mode>${PROACTIVE_MULTI_AGENT_MODE_TEXT}</multi_agent_mode>`;
+}
+
+
+
+export const V2_GUIDANCE_CHAR_BUDGET = 700;
+
+export function applyInjectionPlaceholders(prompt: string, model?: string, effort?: string, roster?: string): string {
+  return prompt
+    .replaceAll("{{model}}", model ?? "")
+    .replaceAll("{{effort}}", effort ?? "")
+    .replaceAll("{{roster}}", roster ?? "");
+}
+
+
+
+export function subagentRosterText(models: Array<{ model: string; efforts: string[] }>): string {
+  if (models.length === 0) return "";
+  const ladders = new Set(models.map(model => model.efforts.join("/")));
+  if (!ladders.has("") && ladders.size === 1) {
+    return ` Available models (reasoning_effort ${[...ladders][0]}): ${models
+      .map(model => `"${model.model}"`)
+      .join(", ")}.`;
+  }
+  const entries = models.map(model => model.efforts.length > 0
+    ? `"${model.model}" (${model.efforts.join("/")})`
+    : `"${model.model}"`);
+  return ` Available models (valid reasoning_effort): ${entries.join(", ")}.`;
+}
+
+
+
+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;
+  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];
+    if (last && typeof last === "object" && (last as { type?: string }).type === "compaction_trigger") {
+      raw.input.splice(raw.input.length - 1, 0, devItem);
+    } else {
+      raw.input.push(devItem);
+    }
+  }
+}
+
+

package/src/server/responses/compact.ts

@@ -0,0 +1,342 @@
+import type { Server } from "bun";
+import { bridgeToResponsesSSE, buildResponseJSON, formatErrorResponse, type ResponsesTerminalStatus } from "../../bridge";
+import {
+  getConfigPath,
+  multiAgentGuidanceEnabled,
+  resolveEnvValue,
+} from "../../config";
+import { parseRequest } from "../../responses/parser";
+import { buildCompactV1Output, COMPACT_PROMPT, decodeCompactionSummary, extractCompactUserMessages } from "../../responses/compaction";
+import { FORWARD_HEADERS, sanitizeReasoningInputContent } from "../../adapters/openai-responses";
+import { expandPreviousResponseInput, previousResponseProviderState, rememberResponseState } from "../../responses/state";
+import { routeModel } from "../../router";
+import {
+  advanceComboAfterFailure,
+  comboDefaultEffort,
+  comboFailureDecision,
+  comboIdFromRawBody,
+  concreteComboRequestBody,
+  getCombo,
+  isComboTargetInCooldown,
+  NoAvailableComboTargetsError,
+  noteComboSuccess,
+  parseRetryAfterMs,
+  pickComboTarget,
+  targetKey,
+} from "../../combos";
+import { isInjectionDebugEnabled } from "../../lib/debug-settings";
+import { injectionDebugLog } from "../../lib/injection-debug-log";
+import { modelInList, namespacedToolName } from "../../types";
+import type { AdapterEvent, OcxConfig, OcxParsedRequest, OcxProviderConfig, OcxProviderContinuationState, OcxUsage } from "../../types";
+import {
+  forceRefreshOAuthAccessSnapshot,
+  getOAuthCredentialApiBaseUrl,
+  getOAuthCredentialProjectId,
+  getValidAccessTokenSnapshot,
+  type OAuthAccessSnapshot,
+  UnsupportedOAuthProviderError,
+} from "../../oauth";
+import { buildWebSearchTool, planWebSearch, runWithWebSearch, shouldResolveOpenAiWebSearchSidecar } from "../../web-search";
+import { describeImagesInPlace, planVisionSidecar, shouldResolveOpenAiVisionSidecar, stripImagesInPlace } from "../../vision";
+import { createAdapterEventQueue, preflightAdapterEvents } from "../../adapters/run-turn-queue";
+import {
+  applyCodexAuthContextToProvider,
+  CodexAccountCooldownError,
+  CodexAuthContextError,
+  CodexDirectAuthenticationError,
+  CodexPoolAuthenticationError,
+  CodexThreadAffinityExpiredError,
+  headersForCodexAuthContext,
+  isCodexAuthContextUsable,
+  resolveCodexAuthContext,
+  type CodexAuthContext,
+} from "../../codex/auth-context";
+import {
+  formatCodexProviderForLog,
+  recordCodexUpstreamOutcome,
+  type CodexUpstreamOutcome,
+} from "../../codex/routing";
+import { fetchWithResetRetry, fetchWithTransientRetry, applyUpstreamRecoveryInit } from "../../lib/upstream-retry";
+import { ForwardAdmissionCredentialError, validateForwardAdmissionCredential } from "../auth-cors";
+import { listOpenAiForwardSidecarCandidates, resolveFirstUsableOpenAiSidecar, type ResolvedOpenAiForwardSidecar } from "../../providers/openai-sidecar";
+import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers";
+import { slugsEquivalent } from "../../providers/slug-codec";
+import { applyOpenAiVirtualModel, resolveOpenAiCompactModel } from "../../providers/openai-virtual-models";
+import { isUsageDebugEnabled } from "../../usage/debug";
+import { readJsonRequestBody, DecompressedBodyTooLargeError, UnsupportedContentEncodingError } from "../request-decompress";
+import { resolveAdapter, resolveWireProtocolOverride } from "../adapter-resolve";
+import { hasKeyPoolFailover, rotateProviderTransportOn429 } from "../../providers/key-failover";
+import { shouldAttemptImageTierRetry } from "../image-retry";
+import { resolveProviderTransport } from "../../providers/xai-transport";
+import type { WsData } from "../ws-bridge";
+import { registerTurn, trackStreamLifetime, unregisterTurn } from "../lifecycle";
+import { redactSecretString } from "../../lib/redact";
+import { readBoundedResponseBody } from "../../lib/bounded-body";
+import { supportedLadderFor } from "../effort-policy";
+import {
+  beginRequestAttempt,
+  catalogModelSupportsServiceTier,
+  finishRequestAttempt,
+  inspectResponseLogJson,
+  noteAttemptSend,
+  readConfiguredCodexServiceTier,
+  requestLogSpeedLabel,
+  sealRequestAttemptIdentity,
+  usageFromResponsesPayload,
+  type RequestLogContext,
+} from "../request-log";
+import type { AttemptRecoveryKind } from "../../usage/log";
+import {
+  consumeForInspection,
+  consumeForResponseLogMetadata,
+  markNativePassthroughSseResponse,
+  relaySseWithFailedTail,
+  relayWithAbort,
+  sanitizePassthroughHeaders,
+} from "../relay";
+import { hasResponsesItemIdRepair, relaySseWithResponsesItemIdRepair } from "../responses-item-id-repair";
+import type { EffectiveSubagentRoster, SpawnAgentSurface } from "../../codex/catalog";
+
+import { decodeRequestErrorResponse, handleResponses, usesCodexForwardPoolAuth } from "./core";
+import { fetchWithHeaderTimeout, providerFetch, safeHostLabel } from "./fetch-helpers";
+
+export const COMPACT_RESPONSE_MAX_BYTES = 32 * 1024 * 1024;
+
+export function compactResponseTooLargeError(): Response {
+  return new Response(JSON.stringify({
+    error: {
+      message: "Compact response exceeded 32 MiB",
+      type: "compact_response_too_large",
+      code: "compact_response_too_large",
+    },
+  }), { status: 502, headers: { "Content-Type": "application/json" } });
+}
+
+
+
+export async function bufferCompactResponse(upstream: Response, signal: AbortSignal): Promise<Response> {
+  const reader = upstream.body?.getReader();
+  const contentType = upstream.headers.get("content-type") ?? "application/json";
+  if (!reader) return new Response(null, { status: upstream.status, headers: { "Content-Type": contentType } });
+  const declaredLength = Number(upstream.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > COMPACT_RESPONSE_MAX_BYTES) {
+    await reader.cancel("compact_response_too_large").catch(() => undefined);
+    return compactResponseTooLargeError();
+  }
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  try {
+    while (true) {
+      if (signal.aborted) {
+        await reader.cancel(signal.reason).catch(() => undefined);
+        return formatErrorResponse(499, "client_cancelled", "Client cancelled compact request");
+      }
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > COMPACT_RESPONSE_MAX_BYTES) {
+        await reader.cancel("compact_response_too_large").catch(() => undefined);
+        return compactResponseTooLargeError();
+      }
+      chunks.push(value);
+    }
+  } catch {
+    if (signal.aborted) return formatErrorResponse(499, "client_cancelled", "Client cancelled compact request");
+    return formatErrorResponse(502, "upstream_error", "Failed to read compact response");
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new Response(body, { status: upstream.status, headers: { "Content-Type": contentType } });
+}
+
+
+
+export async function handleResponsesCompact(
+  req: Request,
+  config: OcxConfig,
+  logCtx: RequestLogContext,
+): Promise<Response> {
+  let body: unknown;
+  try {
+    body = await readJsonRequestBody(req);
+  } catch (err) {
+    return decodeRequestErrorResponse(err, "responses-compact");
+  }
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return formatErrorResponse(400, "invalid_request_error", "Invalid compaction request body");
+  }
+  const raw = body as { model?: unknown; input?: unknown };
+  if (typeof raw.model !== "string" || raw.model.length === 0) {
+    return formatErrorResponse(400, "invalid_request_error", "compaction request requires a model");
+  }
+
+  let route;
+  try {
+    route = routeModel(config, raw.model);
+  } catch (err) {
+    return formatErrorResponse(404, "invalid_request_error", err instanceof Error ? err.message : String(err));
+  }
+  const selectedModelId = route.modelId;
+  logCtx.requestedModel = raw.model;
+  logCtx.model = selectedModelId;
+  logCtx.provider = route.providerName;
+  logCtx.providerAdapter = route.provider.adapter;
+  const virtual = resolveOpenAiCompactModel(route.providerName, selectedModelId);
+  if (virtual) {
+    route.modelId = virtual.wireModelId;
+    logCtx.model = virtual.selectedModelId;
+    logCtx.resolvedModel = virtual.wireModelId;
+  } else {
+    logCtx.resolvedModel = route.modelId;
+  }
+
+  if (route.codexAccountMode === "direct") {
+    try { validateForwardAdmissionCredential(req.headers, config); }
+    catch (err) {
+      if (err instanceof ForwardAdmissionCredentialError) return formatErrorResponse(401, "authentication_error", err.message);
+      throw err;
+    }
+  }
+
+  if (route.provider.adapter === "openai-responses") {
+    // Native ChatGPT/OpenAI model: forward the compact request verbatim to the real backend.
+    // Resolve the SAME pool/thread auth context as /v1/responses — forwarding the caller's raw
+    // headers would run compaction on the wrong account (or 401) whenever a pool account is
+    // active for this thread while normal turns succeed.
+    let compactProvider = route.provider;
+    let authCtx: CodexAuthContext = { kind: "main", accountId: null };
+    const headers = new Headers({ "content-type": "application/json" });
+    try {
+      if (route.codexAccountMode) {
+        authCtx = await resolveCodexAuthContext(req.headers, config, route.codexAccountMode);
+        const selected = headersForCodexAuthContext(req.headers, authCtx);
+        compactProvider = applyCodexAuthContextToProvider(route.provider, authCtx, route.codexAccountMode);
+        for (const name of FORWARD_HEADERS) {
+          const value = selected.get(name);
+          if (value) headers.set(name, value);
+        }
+        const override = (compactProvider as { _codexAccountOverride?: { accessToken: string; chatgptAccountId: string } })._codexAccountOverride;
+        if (override) {
+          headers.set("authorization", `Bearer ${override.accessToken}`);
+          headers.set("chatgpt-account-id", override.chatgptAccountId);
+        }
+      }
+    } catch (err) {
+      if (err instanceof CodexAccountCooldownError) {
+        return formatErrorResponse(429, "rate_limit_error", "Selected Codex account is cooling down");
+      }
+      if (err instanceof CodexThreadAffinityExpiredError) {
+        return formatErrorResponse(409, "invalid_request_error", "Codex thread account affinity expired; start a new session");
+      }
+      if (err instanceof CodexAuthContextError) {
+        return formatErrorResponse(401, "authentication_error", "Selected Codex account needs reauthentication");
+      }
+      if (err instanceof CodexPoolAuthenticationError || err instanceof CodexDirectAuthenticationError) {
+        return formatErrorResponse(401, "authentication_error", err.message);
+      }
+      throw err;
+    }
+    const base = (compactProvider.baseUrl ?? "").replace(/\/$/, "");
+    if (compactProvider.apiKey) headers.set("authorization", `Bearer ${resolveEnvValue(compactProvider.apiKey)}`);
+    const { reasoning: _reasoning, ...compactBodyRaw } = raw as typeof raw & { reasoning?: unknown };
+    // The regular /v1/responses path applies sanitizeReasoningInputContent via the adapter's
+    // buildRequest, but the compact endpoint forwards directly. Apply the same sanitizer here
+    // so routed-model reasoning items (reasoning_text content) don't 400 the ChatGPT backend.
+    const compactBody = sanitizeReasoningInputContent(compactBodyRaw) as typeof compactBodyRaw;
+    const compactUrl = `${base}/responses/compact`;
+    const compactThreadId = req.headers.get("x-codex-parent-thread-id");
+    const connectMs = config.connectTimeoutMs ?? 200_000;
+    const recordCompactPoolOutcome = (outcome: CodexUpstreamOutcome, meta: { retryAfter?: string | null } = {}) => {
+      if (!usesCodexForwardPoolAuth(authCtx, route.provider)) return;
+      recordCodexUpstreamOutcome(config, authCtx.accountId, outcome, {
+        ...meta,
+        threadId: compactThreadId,
+      });
+    };
+    let upstream: Response;
+    try {
+      // Same connect timeout + keep-alive reset + transient-5xx recovery as /v1/responses —
+      // compact hits the same ChatGPT host and must soft-avoid / clear affinity (#186).
+      upstream = await fetchWithTransientRetry(
+        recovery => fetchWithHeaderTimeout(
+          compactUrl,
+          applyUpstreamRecoveryInit({
+            method: "POST",
+            headers,
+            body: JSON.stringify({ ...compactBody, model: route.modelId }),
+          }, recovery),
+          req.signal,
+          connectMs,
+          false,
+          providerFetch(compactProvider),
+        ),
+        { abortSignal: req.signal, label: safeHostLabel(compactUrl) },
+      );
+    } catch (err) {
+      if (req.signal.aborted) return formatErrorResponse(499, "client_cancelled", "Client cancelled compact request");
+      const outcome = err instanceof Error && err.name === "TimeoutError" ? "timeout" : "connect_error";
+      recordCompactPoolOutcome(outcome);
+      return formatErrorResponse(502, "upstream_error", "Failed to connect to compact upstream");
+    }
+    const retryAfter = upstream.headers.get("retry-after");
+    const buffered = await bufferCompactResponse(upstream, req.signal);
+    // Record pool health only after the body is fully delivered (or definitively failed).
+    // A premature 200 would clear soft-avoid while the client still sees a buffer 502.
+    if (buffered.status === 499) {
+      return buffered;
+    }
+    if (upstream.ok && buffered.status >= 500) {
+      // The upstream account returned 200 — it is healthy. The buffering failure
+      // (oversized body exceeding COMPACT_RESPONSE_MAX_BYTES, or a rare mid-read
+      // reset on a small JSON payload) is a local proxy issue, not account flakiness.
+      // Record the upstream status so a deterministic payload-size limit does not
+      // soft-avoid a healthy account and rotate a thread for 30s.
+      recordCompactPoolOutcome(upstream.status, { retryAfter });
+    } else {
+      recordCompactPoolOutcome(upstream.status, { retryAfter });
+    }
+    return buffered;
+  }
+
+  // ROUTED model: run the v2 synthetic-compaction turn internally (appends COMPACT_PROMPT, no
+  // tools) and decode the resulting ocx1 envelope into plain v1 replacement-history items.
+  const inputItems = Array.isArray(raw.input) ? (raw.input as unknown[]) : [];
+  const internalBody = {
+    ...raw,
+    stream: false,
+    input: [...inputItems, { type: "compaction_trigger" }],
+  };
+  const internalHeaders = new Headers({ "content-type": "application/json" });
+  for (const name of FORWARD_HEADERS) {
+    const value = req.headers.get(name);
+    if (value) internalHeaders.set(name, value);
+  }
+  const internalReq = new Request("http://localhost/v1/responses", {
+    method: "POST",
+    headers: internalHeaders,
+    body: JSON.stringify(internalBody),
+  });
+  const response = await handleResponses(internalReq, config, logCtx, { abortSignal: req.signal });
+  if (!response.ok) return response;
+  let json: { output?: unknown[] };
+  try {
+    json = await response.json() as { output?: unknown[] };
+  } catch {
+    return formatErrorResponse(502, "server_error", "compaction turn returned a non-JSON response");
+  }
+  const compactionItem = (json.output ?? []).find(
+    (item): item is { type: string; encrypted_content?: string } =>
+      !!item && typeof item === "object" && (item as { type?: string }).type === "compaction",
+  );
+  const summary = compactionItem?.encrypted_content
+    ? decodeCompactionSummary(compactionItem.encrypted_content) ?? ""
+    : "";
+  const output = buildCompactV1Output(extractCompactUserMessages(inputItems), summary);
+  return new Response(JSON.stringify({ output }), { headers: { "Content-Type": "application/json" } });
+}
+
+