@fudrouter/fsrouter 0.6.72 → 0.6.74

package/dist/open-sse/executors/codex.js

@@ -1,753 +1,269 @@
-// ─── Codex Executor (AMRouter) ─────────────────────────────────────────────
-// Converted from OmniRoute TypeScript to plain JavaScript for AMRouter.
-// Inlines: codex/quota.ts, codex/tools.ts sub-modules.
-// Preserves all key business logic from OmniRoute codex.ts (1270 lines).
-
-import { createRequire } from "module";
 import { BaseExecutor } from "./base.js";
-import { PROVIDERS } from "../config/providers.js";
 import { CODEX_DEFAULT_INSTRUCTIONS } from "../config/codexInstructions.js";
-import { normalizeResponsesInput } from "../translator/formats/responsesApi.js";
-import { fetchImageAsBase64 } from "../translator/concerns/image.js";
-import { getModelUpstreamId } from "../config/providerModels.js";
-import { DEFAULT_RETRY_CONFIG, HTTP_STATUS, resolveRetryEntry } from "../config/runtimeConfig.js";
-import { resolveSessionId } from "../utils/sessionManager.js";
+import { PROVIDERS } from "../config/providers.js";
 import {
   refreshProviderCredentials,
   shouldRefreshCredentials,
 } from "../services/oauthCredentialManager.js";
-import { getAccessToken } from "../services/tokenRefresh.js";
+import { normalizeResponsesInput } from "../translator/formats/responsesApi.js";
+import { fetchImageAsBase64 } from "../translator/concerns/image.js";
+import { getModelUpstreamId } from "../config/providerModels.js";
+import { DEFAULT_RETRY_CONFIG, HTTP_STATUS, resolveRetryEntry } from "../config/runtimeConfig.js";
 import { dbg } from "../utils/debugLog.js";
+import { resolveSessionId } from "../utils/sessionManager.js";
 
-// ─── Inline stubs for OmniRoute-only modules ─────────────────────────────
-
-// OmniRoute codexInstructions.ts also exports CODEX_CHAT_DEFAULT_INSTRUCTIONS
-const CODEX_CHAT_DEFAULT_INSTRUCTIONS =
-  "You are a helpful assistant. Follow the developer instructions in the conversation.";
-
-// OmniRoute config/codexClient.ts
-function getCodexClientVersion() { return "0.200.0"; }
-function getCodexUserAgent() { return "codex-cli/0.200.0 (node)"; }
-function normalizeCodexSessionId(v) {
-  if (typeof v !== "string") return null;
-  const t = v.trim();
-  return t.length > 0 ? t.slice(0, 256) : null;
-}
-
-// OmniRoute config/codexIdentity.ts — client identity for Codex backend
-function createCodexClientIdentity(sessionId, providerSpecificData) {
-  // Return a minimal identity object; real OmniRoute reads from config/DB
-  if (!sessionId) return null;
-  return { sessionId, clientId: "amrouter" };
-}
-function applyCodexClientIdentityHeaders(headers, identity) {
-  if (!identity) return;
-  // Codex backend expects these headers for identity tracking
-  if (identity.sessionId) headers["session_id"] = identity.sessionId;
-}
-function applyCodexClientMetadata(body, identity) {
-  if (!identity) return;
-  // Codex client_metadata is used for telemetry
-  if (!body.client_metadata) body.client_metadata = {};
-  body.client_metadata.client_id = identity.clientId || "amrouter";
-}
-
-// OmniRoute lib/providers/requestDefaults.ts
-function getCodexRequestDefaults(providerSpecificData) {
-  return {
-    serviceTier: providerSpecificData?.serviceTier || null,
-    reasoningEffort: providerSpecificData?.reasoningEffort || null,
-  };
-}
-
-// OmniRoute config/codexQuotaScopes.ts — scope-aware rate limiting
-function getCodexModelScope(model) {
-  if (typeof model !== "string") return "codex";
-  const lower = model.toLowerCase();
-  if (lower.includes("spark") || lower.includes("mini")) return "spark";
-  return "codex";
-}
-function getCodexRateLimitKey(model, connectionId) {
-  const scope = getCodexModelScope(model);
-  return `${scope}:${connectionId || "default"}`;
-}
-
-// OmniRoute services/responsesInputSanitizer.ts
-function sanitizeResponsesInputItems(input, _strict, options) {
-  if (!Array.isArray(input)) return input;
-  const dropInternal = options?.dropInternalAssistantMessages;
-  return input.filter((item) => {
-    if (!item || typeof item !== "object") return true;
-    // Drop internal assistant messages that aren't meant for upstream
-    if (dropInternal && item.role === "assistant" && item._internal) return false;
-    return true;
-  });
-}
-
-// OmniRoute services/codexVerbosity.ts
-function normalizeCodexVerbosity(body) {
-  // Fold Chat-style `verbosity` / Responses `text.verbosity` into text:{verbosity}
-  const verbosity = body.verbosity;
-  if (verbosity !== undefined) {
-    delete body.verbosity;
-    if (typeof verbosity === "string" && verbosity.trim()) {
-      body.text = { ...(body.text && typeof body.text === "object" ? body.text : {}), verbosity: verbosity.trim().toLowerCase() };
-    }
-  }
-  // Ensure text.verbosity is a valid value
-  if (body.text && typeof body.text === "object" && body.text.verbosity) {
-    const v = String(body.text.verbosity).toLowerCase();
-    const VALID = new Set(["low", "medium", "high"]);
-    if (!VALID.has(v)) delete body.text.verbosity;
-  }
-}
-
-// OmniRoute services/thinkingBudget.ts
-const ThinkingMode = { PASSTHROUGH: "passthrough", DEFAULT: "default" };
-function getThinkingBudgetConfig() {
-  const mode = process.env.CODEX_THINKING_MODE || ThinkingMode.DEFAULT;
-  return { mode };
-}
-
-// OmniRoute utils/cors.ts
-const CORS_HEADERS = {
-  "Access-Control-Allow-Origin": "*",
-  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
-  "Access-Control-Allow-Headers": "Content-Type, Authorization",
-};
-
-// OmniRoute utils/responsesInputNormalization.ts
-function normalizeCodexResponsesInput(body) {
-  // Handle messages/prompt → input conversion (Cursor, other clients)
-  if (!body.input && Array.isArray(body.messages)) {
-    body.input = body.messages.map((msg) => ({
-      type: "message",
-      role: typeof msg.role === "string" ? msg.role : "user",
-      ...(typeof msg.phase === "string" ? { phase: msg.phase } : {}),
-      content:
-        typeof msg.content === "string"
-          ? [{ type: "input_text", text: msg.content }]
-          : Array.isArray(msg.content)
-            ? msg.content.map((cp) => {
-                if (cp && typeof cp === "object" && !Array.isArray(cp) && cp.type === "text") {
-                  return { type: "input_text", text: cp.text };
-                }
-                return cp;
-              })
-            : [],
-    }));
-  } else if (!body.input && typeof body.prompt === "string" && body.prompt.trim()) {
-    body.input = [
-      { type: "message", role: "user", content: [{ type: "input_text", text: body.prompt }] },
-    ];
-  } else if (!body.input && Array.isArray(body.prompt)) {
-    body.input = body.prompt.map((p) => ({
-      type: "message",
-      role: "user",
-      content: [{ type: "input_text", text: typeof p === "string" ? p : JSON.stringify(p) }],
-    }));
-  }
-}
-
-// OmniRoute utils/providerRequestLogging.ts — stub
-const prl = {
-  async captureCurrentProviderBody(_url, _headers, _body, _log) { /* noop */ },
-};
+// SSE error patterns inside 200-OK bodies. Some retry same account first; capacity rotates accounts.
+const CODEX_SSE_RETRY_PATTERNS = ["server_is_overloaded", "service_unavailable_error"];
+const CODEX_SSE_ACCOUNT_FALLBACK_PATTERNS = ["selected model is at capacity", "model_at_capacity"];
+const CODEX_SSE_USER_OUTPUT_PATTERNS = [
+  "event: response.output_text.delta",
+  "event: response.function_call_arguments.delta",
+  '"type":"response.output_text.delta"',
+  '"type":"response.function_call_arguments.delta"',
+];
+const CODEX_SSE_PEEK_BYTES = 256 * 1024;
+const CODEX_MODEL_CAPACITY_MESSAGE = "Selected model is at capacity. Please try a different model.";
 
-// ─── Constants ──────────────────────────────────────────────────────────────
+// Server-generated item id prefixes that Codex /responses cannot resolve when store=false
+const SERVER_ID_PATTERN = /^(rs|fc|resp|msg)_/;
 
-const EFFORT_ORDER = ["none", "low", "medium", "high", "xhigh"];
-const CODEX_FAST_WIRE_VALUE = "priority";
-const CODEX_RESPONSES_WS_URL = "wss://chatgpt.com/backend-api/codex/responses";
-const CODEX_REASONING_ENCRYPTED_CONTENT_INCLUDE = "reasoning.encrypted_content";
-const CODEX_DEFAULT_REASONING_SUMMARY = "auto";
+// Hosted tool types that Codex/OpenAI Responses executes server-side
+const CODEX_HOSTED_TOOL_TYPES = new Set([
+  "image_generation", "web_search", "web_search_preview", "file_search",
+  "computer", "computer_use_preview", "code_interpreter", "mcp", "local_shell",
+  "tool_search"
+]);
 
-const MAX_EFFORT_BY_MODEL = {
-  "gpt-5.3-codex": "xhigh",
-  "gpt-5.1-codex-max": "xhigh",
-  "gpt-5-mini": "high",
-  "gpt-5.1-mini": "high",
-  "gpt-4.1-mini": "high",
-};
+// Responses-native freeform tools carry a name plus format payload and must pass through intact.
+const CODEX_PASSTHROUGH_TOOL_TYPES = new Set(["custom"]);
 
+// Allowlist of fields accepted by Codex Responses API — anything else is stripped
 const RESPONSES_API_ALLOWLIST = new Set([
   "model", "input", "instructions", "tools", "tool_choice", "stream", "store",
-  "reasoning", "service_tier", "include", "prompt_cache_key", "client_metadata", "text",
+  "reasoning", "service_tier", "include", "prompt_cache_key", "client_metadata",
+  "text"
 ]);
 
-// Server-generated item id prefixes that Codex /responses cannot resolve when store=false
-const SERVER_ID_PATTERN = /^(rs|fc|resp|msg)_/;
-// ─── Inlined: codex/quota.ts ────────────────────────────────────────────────
-// Quota parsing + reset/cooldown scheduling (pure).
-
-/**
- * Parsed quota snapshot from Codex response headers.
- * Codex includes per-account usage windows that allow precise reset scheduling.
- */
-// (CodexQuotaSnapshot is a plain object: { usage5h, limit5h, resetAt5h, usage7d, limit7d, resetAt7d })
-
-export function parseCodexQuotaHeaders(headers) {
-  const usage5h = headers["x-codex-5h-usage"] ?? null;
-  const limit5h = headers["x-codex-5h-limit"] ?? null;
-  const resetAt5h = headers["x-codex-5h-reset-at"] ?? null;
-  const usage7d = headers["x-codex-7d-usage"] ?? null;
-  const limit7d = headers["x-codex-7d-limit"] ?? null;
-  const resetAt7d = headers["x-codex-7d-reset-at"] ?? null;
-
-  if (!usage5h && !limit5h && !resetAt5h && !usage7d && !limit7d && !resetAt7d) {
-    return null;
-  }
-
-  return {
-    usage5h: usage5h ? parseFloat(usage5h) : 0,
-    limit5h: limit5h ? parseFloat(limit5h) : Infinity,
-    resetAt5h: resetAt5h ?? null,
-    usage7d: usage7d ? parseFloat(usage7d) : 0,
-    limit7d: limit7d ? parseFloat(limit7d) : Infinity,
-    resetAt7d: resetAt7d ?? null,
-  };
-}
-
-export function getCodexResetTime(quota) {
-  const times = [];
-  if (quota.resetAt7d) {
-    const t = new Date(quota.resetAt7d).getTime();
-    if (!isNaN(t) && t > Date.now()) times.push(t);
-  }
-  if (quota.resetAt5h) {
-    const t = new Date(quota.resetAt5h).getTime();
-    if (!isNaN(t) && t > Date.now()) times.push(t);
-  }
-  if (times.length === 0) return null;
-  return Math.max(...times);
-}
-
-export function getCodexDualWindowCooldownMs(quota, threshold = 0.95) {
-  const now = Date.now();
-  const ratio7d = quota.limit7d > 0 && Number.isFinite(quota.limit7d) ? quota.usage7d / quota.limit7d : 0;
-  const ratio5h = quota.limit5h > 0 && Number.isFinite(quota.limit5h) ? quota.usage5h / quota.limit5h : 0;
-
-  if (ratio7d >= threshold && quota.resetAt7d) {
-    const resetTime = new Date(quota.resetAt7d).getTime();
-    if (resetTime > now) return { cooldownMs: resetTime - now, window: "7d" };
-  }
-  if (ratio5h >= threshold && quota.resetAt5h) {
-    const resetTime = new Date(quota.resetAt5h).getTime();
-    if (resetTime > now) return { cooldownMs: resetTime - now, window: "5h" };
+// Convert role=system → role=developer in body.input (keeps content in cacheable prefix)
+function convertSystemToDeveloperRole(body) {
+  if (!Array.isArray(body.input)) return;
+  for (const item of body.input) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const isSystemMsg = item.role === "system" && (!item.type || item.type === "message");
+    if (isSystemMsg) item.role = "developer";
   }
-  return { cooldownMs: 0, window: "none" };
 }
 
-// ─── Inlined: codex/tools.ts ────────────────────────────────────────────────
-// Codex Responses-API tool normalization (hosted-tool passthrough + free-plan gating).
-
-export const CODEX_HOSTED_TOOL_TYPES = new Set([
-  "tool_search", "image_generation", "web_search", "web_search_preview",
-  "file_search", "computer", "computer_use_preview", "code_interpreter", "mcp",
-]);
-
-export function isCodexFreePlan(providerSpecificData) {
-  if (!providerSpecificData || typeof providerSpecificData !== "object") return false;
-  const plan = providerSpecificData.workspacePlanType;
-  return typeof plan === "string" && plan.trim().toLowerCase() === "free";
+// Strip server-generated item IDs (rs_/fc_/resp_/msg_) from input — avoids 404 with store=false
+function stripStoredItemReferences(body) {
+  if (!Array.isArray(body.input)) return;
+  body.input = body.input.filter((item) => {
+    if (typeof item === "string" && SERVER_ID_PATTERN.test(item)) return false;
+    if (item && typeof item === "object" && !Array.isArray(item)) {
+      if (item.type === "item_reference") return false;
+      if (typeof item.id === "string" && SERVER_ID_PATTERN.test(item.id)) delete item.id;
+    }
+    return true;
+  });
 }
 
-export function normalizeCodexTools(body, options) {
+// Flatten Chat-Completions tool shape into Responses flat format + filter unsupported tools
+function normalizeCodexTools(body) {
   if (!Array.isArray(body.tools)) return;
-  const dropImageGen = options?.dropImageGeneration;
-  const preserveCustom = options?.preserveCustomTools;
-
-  const validToolNames = new Set();
-  body.tools = body.tools.filter((toolValue) => {
-    if (!toolValue || typeof toolValue !== "object" || Array.isArray(toolValue)) return false;
-
-    const toolType = typeof toolValue.type === "string" ? toolValue.type : "";
-
-    // Preserve namespace tools (MCP tool groups)
-    if (toolType === "namespace") {
-      if (Array.isArray(toolValue.tools)) {
-        for (const st of toolValue.tools) {
-          if (st && typeof st === "object" && !Array.isArray(st)) {
-            const name = typeof st.name === "string" ? st.name.trim().slice(0, 128) : "";
-            if (name) validToolNames.add(name);
-          }
+  const validNames = new Set();
+  body.tools = body.tools.filter((tool) => {
+    if (!tool || typeof tool !== "object" || Array.isArray(tool)) return false;
+    const type = typeof tool.type === "string" ? tool.type : "";
+    if (type === "namespace") {
+      if (Array.isArray(tool.tools)) {
+        for (const st of tool.tools) {
+          const n = typeof st?.name === "string" ? st.name.trim().slice(0, 128) : "";
+          if (n) validNames.add(n);
         }
       }
       return true;
     }
-
-    // Native Codex clients send Responses API custom tools (apply_patch etc.)
-    if (toolType === "custom" && preserveCustom === true) {
-      const name = typeof toolValue.name === "string" ? toolValue.name.trim().slice(0, 128) : "";
-      if (!name) return false;
-      toolValue.name = name;
-      validToolNames.add(name);
-      return true;
-    }
-
-    if (toolType !== "function") {
-      // Not a function tool — check if it's a known hosted tool
-      const hasFunctionObject = toolValue.function && typeof toolValue.function === "object";
-      const hasName = typeof toolValue.name === "string";
-      if (!toolType || hasFunctionObject || hasName) return false;
-      if (CODEX_HOSTED_TOOL_TYPES.has(toolType)) {
-        if (toolType === "image_generation" && dropImageGen) return false;
-        return true;
-      }
-      console.debug(`[Codex] dropping unknown hosted tool type: ${toolType}`);
-      return false;
+    if (type !== "function") {
+      if (CODEX_PASSTHROUGH_TOOL_TYPES.has(type)) return true;
+      if (!type || tool.function || typeof tool.name === "string") return false;
+      return CODEX_HOSTED_TOOL_TYPES.has(type);
     }
-
-    // Function tool — flatten Chat Completions shape into Responses flat format
-    const rawName = typeof toolValue.name === "string"
-      ? toolValue.name
-      : toolValue.function && typeof toolValue.function === "object" && !Array.isArray(toolValue.function) && typeof toolValue.function.name === "string"
-        ? toolValue.function.name
-        : "";
+    const fn = tool.function && typeof tool.function === "object" && !Array.isArray(tool.function) ? tool.function : null;
+    const rawName = typeof tool.name === "string" ? tool.name : (typeof fn?.name === "string" ? fn.name : "");
     const name = rawName.trim();
     if (!name) return false;
-
-    const fn = toolValue.function && typeof toolValue.function === "object" && !Array.isArray(toolValue.function)
-      ? toolValue.function : null;
-    const description = typeof toolValue.description === "string"
-      ? toolValue.description
-      : typeof fn?.description === "string" ? fn.description : "";
-    const parameters = (toolValue.parameters && typeof toolValue.parameters === "object" && !Array.isArray(toolValue.parameters))
-      ? toolValue.parameters
-      : (fn?.parameters && typeof fn.parameters === "object" && !Array.isArray(fn.parameters)
-        ? fn.parameters
-        : { type: "object", properties: {} });
-    const strict = typeof toolValue.strict === "boolean"
-      ? toolValue.strict
-      : typeof fn?.strict === "boolean" ? fn.strict : undefined;
-
-    // Rewrite in-place to Responses format
-    for (const key of Object.keys(toolValue)) delete toolValue[key];
-    toolValue.type = "function";
-    toolValue.name = name.slice(0, 128);
-    if (description) toolValue.description = description;
-    toolValue.parameters = parameters;
-    if (strict !== undefined) toolValue.strict = strict;
-
-    validToolNames.add(name);
+    const description = typeof tool.description === "string" ? tool.description : (typeof fn?.description === "string" ? fn.description : "");
+    const parameters = (tool.parameters && typeof tool.parameters === "object" && !Array.isArray(tool.parameters))
+      ? tool.parameters
+      : (fn?.parameters && typeof fn.parameters === "object" && !Array.isArray(fn.parameters) ? fn.parameters : { type: "object", properties: {} });
+    for (const k of Object.keys(tool)) delete tool[k];
+    tool.type = "function";
+    tool.name = name.slice(0, 128);
+    if (description) tool.description = description;
+    tool.parameters = parameters;
+    validNames.add(name);
     return true;
   });
-
   // Drop tool_choice if it references an unknown function name
   if (body.tool_choice && typeof body.tool_choice === "object" && !Array.isArray(body.tool_choice)) {
     if (body.tool_choice.type === "function") {
       const n = typeof body.tool_choice.name === "string" ? body.tool_choice.name.trim() : "";
-      if (!n || !validToolNames.has(n)) delete body.tool_choice;
-    } else if (body.tool_choice.type === "local_shell") {
-      delete body.tool_choice;
+      if (!n || !validNames.has(n)) delete body.tool_choice;
     }
   }
 }
-// ─── Core utility functions ─────────────────────────────────────────────────
-
-// wreq-js is a Rust-native module that requires platform-specific .node binaries.
-// Lazy-load with try/catch to gracefully fall back to HTTP when WebSocket unavailable.
-const _wreqRequire = createRequire(import.meta.url);
-
-let _websocketFn = null;
-let _wreqChecked = false;
-let _websocketOverride;
-
-function getCodexWebSocketTransport() {
-  if (_websocketOverride !== undefined) return _websocketOverride;
-  if (_wreqChecked) return _websocketFn;
-  _wreqChecked = true;
-  try {
-    const mod = _wreqRequire("wreq-js");
-    _websocketFn = typeof mod.websocket === "function" ? mod.websocket : null;
-  } catch {
-    console.warn("[codex] wreq-js import failed, websocket disabled");
-    _websocketFn = null;
-  }
-  return _websocketFn;
-}
 
-export function __setCodexWebSocketTransportForTesting(websocket) {
-  _websocketOverride = websocket;
+// Resolve prompt-cache session id: client session → assistant-text-hash → workspaceId → connection
+function resolveCacheSessionId(body, credentials) {
+  return resolveSessionId({
+    headers: credentials?.rawHeaders,
+    body,
+    connectionId: credentials?.connectionId,
+    workspaceId: credentials?.providerSpecificData?.workspaceId,
+    scope: "codex"
+  });
 }
 
-function codexWebSocketUnavailableResponse() {
-  return new Response(
-    JSON.stringify({
-      error: {
-        code: "wreq_unavailable",
-        message: "Codex WebSocket transport unavailable: wreq-js native module is missing for this platform",
-      },
-    }),
-    {
-      status: 503,
-      headers: { "Content-Type": "application/json", ...CORS_HEADERS },
-    },
-  );
+function normalizeReasoningEffort(value) {
+  return value === "max" ? "xhigh" : value;
 }
 
-function splitCodexReasoningSuffix(model) {
-  const modelId = typeof model === "string" ? model : "";
-  for (const level of EFFORT_ORDER) {
-    if (modelId.endsWith(`-${level}`)) {
-      return { baseModel: modelId.slice(0, -`-${level}`.length), effort: level };
+function findNestedMessage(value, depth = 0) {
+  if (!value || depth > 6 || typeof value === "string") return null;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const found = findNestedMessage(item, depth + 1);
+      if (found) return found;
     }
+    return null;
+  }
+  if (typeof value !== "object") return null;
+  if (typeof value.message === "string" && value.message.trim()) return value.message;
+  if (typeof value.error?.message === "string" && value.error.message.trim()) return value.error.message;
+  if (typeof value.response?.error?.message === "string" && value.response.error.message.trim()) return value.response.error.message;
+  for (const child of Object.values(value)) {
+    const found = findNestedMessage(child, depth + 1);
+    if (found) return found;
   }
-  return { baseModel: modelId, effort: null };
+  return null;
 }
 
-export function getCodexUpstreamModel(model) {
-  return splitCodexReasoningSuffix(model).baseModel;
-}
+function extractSseErrorMessage(text, fallback) {
+  const exact = text?.match(/Selected model is at capacity\. Please try a different model\./i)?.[0];
+  if (exact) return exact;
 
-// Convert role=system → role=developer in body.input (GPT-5 cache-aware)
-function convertSystemToDeveloperRole(body) {
-  if (!Array.isArray(body.input)) return;
-  for (const itemValue of body.input) {
-    if (!itemValue || typeof itemValue !== "object" || Array.isArray(itemValue)) continue;
-    const role = typeof itemValue.role === "string" ? itemValue.role : "";
-    const type = typeof itemValue.type === "string" ? itemValue.type : "";
-    if (role === "system" && (!type || type === "message")) {
-      itemValue.role = "developer";
+  for (const line of String(text || "").split(/\r?\n/)) {
+    if (!line.startsWith("data:")) continue;
+    const data = line.slice(5).trim();
+    if (!data || data === "[DONE]") continue;
+    try {
+      const message = findNestedMessage(JSON.parse(data));
+      if (message) return message;
+    } catch {
+      // Ignore non-JSON SSE data lines.
     }
   }
-}
 
-// Strip server-generated item IDs from input — avoids 404 with store=false.
-// Also strips reasoning blobs and empty input repair.
-export function stripStoredItemReferences(body) {
-  if (Array.isArray(body.input) && body.input.length === 0) {
-    body.input = [
-      { type: "message", role: "user", content: [{ type: "input_text", text: "continue" }] },
-    ];
-  }
-  if (!Array.isArray(body.input)) return;
+  return fallback || CODEX_MODEL_CAPACITY_MESSAGE;
+}
 
-  let strippedCount = 0;
-  body.input = body.input.filter((item) => {
-    // Bare string references: "rs_abc123"
-    if (typeof item === "string" && SERVER_ID_PATTERN.test(item)) {
-      strippedCount++;
-      return false;
-    }
-    // Object references: { type: "item_reference", id: "rs_..." }
-    if (item && typeof item === "object" && !Array.isArray(item) && item.type === "item_reference") {
-      strippedCount++;
-      return false;
-    }
-    // Reasoning blobs (encrypted_content) unusable with store=false
-    if (item && typeof item === "object" && !Array.isArray(item) && item.type === "reasoning") {
-      strippedCount++;
-      return false;
-    }
-    // Object items with server-generated IDs: strip the id field but keep the item
-    if (item && typeof item === "object" && !Array.isArray(item)) {
-      if (typeof item.id === "string" && SERVER_ID_PATTERN.test(item.id)) {
-        delete item.id;
-        strippedCount++;
-      }
+function codexSseErrorResponse(status, message) {
+  return new Response(JSON.stringify({
+    error: {
+      message,
+      type: status >= 500 ? "server_error" : "invalid_request_error",
+      code: status === HTTP_STATUS.SERVICE_UNAVAILABLE ? "service_unavailable" : "upstream_error",
     }
-    return true;
+  }), {
+    status,
+    headers: { "Content-Type": "application/json" },
   });
-
-  if (strippedCount > 0) {
-    console.debug(`[Codex] stripStoredItemReferences: sanitized ${strippedCount} server-generated ID(s) from input`);
-  }
 }
 
-// Repair missing function_call_output items (some clients omit them)
-function repairMissingCodexFunctionCallOutputs(body) {
-  if (!Array.isArray(body.input)) return;
-  const existingOutputIds = new Set();
-  for (const item of body.input) {
-    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
-    if (item.type !== "function_call_output") continue;
-    if (typeof item.call_id === "string" && item.call_id.trim()) {
-      existingOutputIds.add(item.call_id.trim());
-    }
-  }
-  const repaired = [];
-  let insertedCount = 0;
-  for (const item of body.input) {
-    repaired.push(item);
-    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
-    if (item.type !== "function_call") continue;
-    const callId = typeof item.call_id === "string" ? item.call_id.trim() : "";
-    if (!callId || existingOutputIds.has(callId)) continue;
-    repaired.push({ type: "function_call_output", call_id: callId, output: "" });
-    existingOutputIds.add(callId);
-    insertedCount++;
-  }
-  if (insertedCount > 0) {
-    body.input = repaired;
-    console.debug(`[Codex] repairMissingCodexFunctionCallOutputs: inserted ${insertedCount} empty function_call_output item(s)`);
+/**
+ * Codex Executor - handles OpenAI Codex API (Responses API format)
+ * Automatically injects default instructions if missing
+ */
+export class CodexExecutor extends BaseExecutor {
+  constructor() {
+    super("codex", PROVIDERS.codex);
+    this._currentSessionId = null;
   }
-}
 
-function getResponsesSubpath(endpointPath) {
-  let normalizedEndpoint = String(endpointPath || "");
-  while (normalizedEndpoint.endsWith("/") && normalizedEndpoint.length > 0) {
-    normalizedEndpoint = normalizedEndpoint.slice(0, -1);
+  /**
+   * Override headers to add codex-specific identity headers.
+   * transformRequest runs BEFORE buildHeaders, sets this._currentSessionId.
+   */
+  buildHeaders(credentials, stream = true) {
+    const headers = super.buildHeaders(credentials, stream);
+    headers["session_id"] = this._currentSessionId || credentials?.connectionId || "default";
+    // Identify client type to Codex backend (matches official codex CLI)
+    if (!headers["originator"]) headers["originator"] = "codex_cli_rs";
+    // Account/workspace binding header — required when multiple Codex accounts
+    // are configured. OAuth import stores ChatGPT account ID as chatgptAccountId;
+    // older/custom rows may use workspaceId/accountId. Prefer explicit workspaceId
+    // but fall back to chatgptAccountId so requests don't cross-bind to the wrong
+    // OpenAI account and surface as token_invalid after adding another account.
+    const accountId =
+      credentials?.providerSpecificData?.workspaceId ||
+      credentials?.providerSpecificData?.chatgptAccountId ||
+      credentials?.providerSpecificData?.accountId;
+    if (typeof accountId === "string" && accountId && !headers["ChatGPT-Account-ID"]) {
+      headers["ChatGPT-Account-ID"] = accountId;
+    }
+    return headers;
   }
-  const lower = normalizedEndpoint.toLowerCase();
-  if (lower === "responses" || lower.endsWith("/responses")) return "";
-  const responsesSlash = "/responses/";
-  const idx = lower.lastIndexOf(responsesSlash);
-  if (idx !== -1) return normalizedEndpoint.slice(idx + "/responses".length);
-  if (lower.startsWith("responses/")) return normalizedEndpoint.slice("responses".length);
-  return null;
-}
-
-export function isCompactResponsesEndpoint(endpointPath) {
-  return getResponsesSubpath(endpointPath)?.toLowerCase() === "/compact";
-}
-
-function normalizeServiceTierValue(value) {
-  if (typeof value !== "string") return undefined;
-  const normalized = value.trim().toLowerCase();
-  if (!normalized) return undefined;
-  if (normalized === "fast") return CODEX_FAST_WIRE_VALUE;
-  return normalized;
-}
 
-function normalizeEffortValue(value) {
-  if (typeof value !== "string") return undefined;
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "max") return "xhigh";
-  return normalized || undefined;
-}
-
-function clampEffort(model, requested) {
-  const max = MAX_EFFORT_BY_MODEL[model] ?? "xhigh";
-  const reqIdx = EFFORT_ORDER.indexOf(requested);
-  const maxIdx = EFFORT_ORDER.indexOf(max);
-  if (reqIdx > maxIdx) {
-    console.debug(`[Codex] clampEffort: "${requested}" → "${max}" (model: ${model})`);
-    return max;
+  buildUrl(model, stream, urlIndex = 0, credentials = null) {
+    const base = super.buildUrl(model, stream, urlIndex, credentials);
+    return this._isCompact ? `${base}/compact` : base;
   }
-  return requested;
-}
 
-function ensureCodexReasoningSummary(body) {
-  const reasoning = body.reasoning && typeof body.reasoning === "object" && !Array.isArray(body.reasoning)
-    ? body.reasoning : null;
-  if (!reasoning || normalizeEffortValue(reasoning.effort) === "none") return;
-  if (!("summary" in reasoning)) reasoning.summary = CODEX_DEFAULT_REASONING_SUMMARY;
-  if (!Array.isArray(body.include)) {
-    body.include = [CODEX_REASONING_ENCRYPTED_CONTENT_INCLUDE];
-    return;
-  }
-  if (!body.include.includes(CODEX_REASONING_ENCRYPTED_CONTENT_INCLUDE)) {
-    body.include = [...body.include, CODEX_REASONING_ENCRYPTED_CONTENT_INCLUDE];
+  async refreshCredentials(credentials, log) {
+    if (!credentials?.refreshToken) return null;
+    return refreshProviderCredentials("codex", credentials, log);
   }
-}
-
-function consumeResponsesStoreMarker(body) {
-  const marker = body._omnirouteResponsesStore;
-  delete body._omnirouteResponsesStore;
-  return marker;
-}
-
-// Global Codex WebSocket kill-switch (default ON in AMRouter)
-function isCodexWsGloballyEnabled() {
-  try {
-    const v = process.env.AMROUTER_CODEX_WS_ENABLED;
-    if (v === "false" || v === "0") return false;
-  } catch { /* noop */ }
-  return true;
-}
 
-export function isCodexResponsesWebSocketRequired(_model, credentials) {
-  if (!isCodexWsGloballyEnabled()) return false;
-  const psd = credentials && typeof credentials === "object" ? credentials.providerSpecificData : null;
-  return !!(psd?.codexTransport === "websocket" && getCodexWebSocketTransport());
-}
-
-function toStatusCode(value) {
-  if (typeof value === "number" && Number.isInteger(value) && value >= 400 && value <= 599) return value;
-  if (typeof value === "string" && /^\d{3}$/.test(value.trim())) {
-    const parsed = Number(value.trim());
-    return parsed >= 400 && parsed <= 599 ? parsed : null;
+  needsRefresh(credentials) {
+    return shouldRefreshCredentials("codex", credentials);
   }
-  return null;
-}
-
-function looksLikeQuotaOrRateLimit(code, type, message) {
-  const haystack = `${code} ${type} ${message}`.toLowerCase();
-  return (
-    haystack.includes("usage_limit_reached") ||
-    haystack.includes("rate_limit") ||
-    haystack.includes("rate limit") ||
-    haystack.includes("quota") ||
-    haystack.includes("too many requests") ||
-    haystack.includes("limit has been reached") ||
-    haystack.includes("limit reached")
-  );
-}
-
-function toCodexResponseFailedEvent(parsed) {
-  const response = parsed.response && typeof parsed.response === "object" && !Array.isArray(parsed.response)
-    ? parsed.response : null;
-  const upstreamError = response?.error && typeof response.error === "object" && !Array.isArray(response.error)
-    ? response.error
-    : parsed.error && typeof parsed.error === "object" && !Array.isArray(parsed.error)
-      ? parsed.error
-      : parsed;
-  const code = typeof upstreamError.code === "string" ? upstreamError.code
-    : typeof upstreamError.type === "string" ? upstreamError.type : "upstream_error";
-  const type = typeof upstreamError.type === "string" ? upstreamError.type : "";
-  const message = typeof upstreamError.message === "string" && upstreamError.message.trim()
-    ? upstreamError.message : "Codex upstream error";
-  const error = { code, message };
-  const explicitStatus = toStatusCode(parsed.status_code) ?? toStatusCode(parsed.status) ??
-    toStatusCode(response?.status_code) ?? toStatusCode(response?.status) ??
-    toStatusCode(upstreamError.status_code) ?? toStatusCode(upstreamError.status);
-  const statusCode = explicitStatus ?? (looksLikeQuotaOrRateLimit(code, type, message) ? 429 : null);
-  if (type) error.type = type;
-  if (statusCode !== null) error.status_code = statusCode;
-  return {
-    type: "response.failed",
-    response: { id: typeof response?.id === "string" ? response.id : null, status: "failed", error },
-  };
-}
-
-// Env-gated kill-switch: drop non-standard codex.* SSE events
-function codexDropNonstandardEvents() {
-  const v = process.env.AMROUTER_CODEX_DROP_NONSTANDARD_EVENTS;
-  return v === "true" || v === "1" || v === "yes";
-}
-
-export function filterNonstandardCodexSse(response) {
-  const contentType = response.headers.get("content-type") || "";
-  if (!response.body || !contentType.includes("text/event-stream")) return response;
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  let buffer = "";
-  const dropBlock = (block) => {
-    const match = /^event:\s*(.+)$/m.exec(block);
-    return !!match && match[1].trim().startsWith("codex.");
-  };
-  const transform = new TransformStream({
-    transform(chunk, controller) {
-      buffer += decoder.decode(chunk, { stream: true });
-      let sep;
-      while ((sep = buffer.indexOf("\n\n")) !== -1) {
-        const block = buffer.slice(0, sep + 2);
-        buffer = buffer.slice(sep + 2);
-        if (!dropBlock(block)) controller.enqueue(encoder.encode(block));
-      }
-    },
-    flush(controller) {
-      if (buffer && !dropBlock(buffer)) controller.enqueue(encoder.encode(buffer));
-    },
-  });
-  return new Response(response.body.pipeThrough(transform), {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers,
-  });
-}
 
-export function encodeResponseSseEvent(raw) {
-  let eventType = "message";
-  let payload = raw;
-  let terminal = false;
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed.type === "string" && parsed.type.trim()) {
-      eventType = parsed.type.trim();
-      if (eventType === "error" || eventType === "response.failed") {
-        const failed = toCodexResponseFailedEvent(parsed);
-        payload = JSON.stringify(failed);
-        eventType = "response.failed";
-      }
-      terminal = eventType === "response.completed" || eventType === "response.failed";
+  /**
+   * Prefetch remote image URLs and inline them as base64 data URIs.
+   * Runs before execute() because Codex backend cannot fetch remote images.
+   * Mutates body.input in place.
+   */
+  async prefetchImages(body) {
+    if (!Array.isArray(body?.input)) return;
+    for (const item of body.input) {
+      if (!Array.isArray(item.content)) continue;
+      const pending = item.content.map(async (c) => {
+        if (c.type !== "image_url") return c;
+        const url = typeof c.image_url === "string" ? c.image_url : c.image_url?.url;
+        const detail = c.image_url?.detail || "auto";
+        if (!url) return c;
+        if (url.startsWith("data:")) return { type: "input_image", image_url: url, detail };
+        const fetched = await fetchImageAsBase64(url, { timeoutMs: 15000 });
+        return { type: "input_image", image_url: fetched?.url || url, detail };
+      });
+      item.content = await Promise.all(pending);
     }
-  } catch {
-    console.warn("[codex] SSE payload parse failed, using raw payload");
-  }
-  if (eventType.startsWith("codex.") && codexDropNonstandardEvents()) {
-    return { sse: "", terminal };
   }
-  if (!payload.trim()) return { sse: "", terminal };
-  return { sse: `event: ${eventType}\ndata: ${payload}\n\n`, terminal };
-}
-
-function toWebSocketUrl(url) {
-  if (/^wss?:\/\//.test(url)) return url;
-  if (url.startsWith("https:")) return url.replace(/^https:/, "wss:");
-  if (url.startsWith("http:")) return url.replace(/^http:/, "ws:");
-  return CODEX_RESPONSES_WS_URL;
-}
-
-function normalizeCodexWsHeaders(headers) {
-  const result = {};
-  for (const [key, value] of Object.entries(headers)) {
-    const lower = key.toLowerCase();
-    if (lower === "host" || lower === "connection" || lower === "upgrade" ||
-        lower === "sec-websocket-key" || lower === "sec-websocket-version" ||
-        lower === "sec-websocket-extensions") continue;
-    result[key] = value;
-  }
-  result.Origin = "https://chatgpt.com";
-  return result;
-}
-
-// Resolve prompt-cache session id for AMRouter
-function resolveCacheSessionId(body, credentials) {
-  return resolveSessionId({
-    headers: credentials?.rawHeaders,
-    body,
-    connectionId: credentials?.connectionId,
-    workspaceId: credentials?.providerSpecificData?.workspaceId,
-    scope: "codex",
-  });
-}
-// ─── CodexExecutor class ────────────────────────────────────────────────────
-
-export class CodexExecutor extends BaseExecutor {
-  constructor() {
-    super("codex", PROVIDERS.codex);
-    this._currentSessionId = null;
-  }
-
-  // ── execute: SSE retry loop + WebSocket transport support ──────────────
 
   async execute(args) {
-    const imgCount = Array.isArray(args.body?.input)
-      ? args.body.input.reduce((n, it) => n + (Array.isArray(it.content) ? it.content.filter(c => c.type === "image_url").length : 0), 0)
-      : 0;
+    const imgCount = Array.isArray(args.body?.input) ? args.body.input.reduce((n, it) => n + (Array.isArray(it.content) ? it.content.filter(c => c.type === "image_url").length : 0), 0) : 0;
     const inputLen = Array.isArray(args.body?.input) ? args.body.input.length : 0;
     dbg("CODEX", `execute start | inputItems=${inputLen} | images=${imgCount} | sessionId=${this._currentSessionId || "pending"}`);
-
-    // Prefetch remote images as base64 (Codex backend can't fetch them)
-    await this.prefetchImages(args.body);
-
-    // WebSocket transport path — opt-in via providerSpecificData.codexTransport
-    const sessionId = this.getPromptCacheSessionId(args.credentials, args.body);
-    const identity = createCodexClientIdentity(sessionId, args.credentials?.providerSpecificData ?? null);
-    const credentials = identity
-      ? {
-          ...args.credentials,
-          providerSpecificData: {
-            ...(args.credentials?.providerSpecificData || {}),
-            codexClientIdentity: identity,
-          },
-        }
-      : args.credentials;
-    const nextArgs = { ...args, credentials };
-
-    if (!isCodexResponsesWebSocketRequired(nextArgs.model, nextArgs.credentials)) {
-      // HTTP SSE path with retry loop
-      return this._executeWithRetry(nextArgs);
+    if (imgCount > 0) {
+      const t0 = Date.now();
+      await this.prefetchImages(args.body);
+      dbg("CODEX", `prefetchImages done | ${Date.now() - t0}ms`);
+    } else {
+      await this.prefetchImages(args.body);
     }
 
-    // WebSocket path
-    return this._executeWebSocket(nextArgs);
-  }
-
-  async _executeWithRetry(args) {
     // Retry loop for SSE-level overloaded errors (200 OK body contains event: error)
+    // Reuses 503 retry config — same semantic: upstream temporarily unavailable
     const retryConfig = { ...DEFAULT_RETRY_CONFIG, ...this.config.retry };
     const { attempts, delayMs } = resolveRetryEntry(retryConfig[503]);
     let attempt = 0;
@@ -755,6 +271,7 @@ export class CodexExecutor extends BaseExecutor {
       const result = await super.execute(args);
       const peek = await this._peekSseTransientError(result.response);
       if (!peek.matched) {
+        // Replace body with re-assembled stream (prefix bytes already read + rest)
         if (peek.replacementBody) {
           result.response = new Response(peek.replacementBody, {
             status: result.response.status,
@@ -762,23 +279,16 @@ export class CodexExecutor extends BaseExecutor {
             headers: result.response.headers,
           });
         }
-        // Filter non-standard codex.* events if kill-switch is on
-        if (codexDropNonstandardEvents()) {
-          const resp = result.response;
-          if (resp?.body) {
-            result.response = filterNonstandardCodexSse(resp);
-          }
-        }
         return result;
       }
       if (peek.accountFallback) {
         args.log?.warn?.("RETRY", `CODEX | SSE account fallback "${peek.message}"`);
-        result.response = this._codexSseErrorResponse(HTTP_STATUS.SERVICE_UNAVAILABLE, peek.message || "Selected model is at capacity.");
+        result.response = codexSseErrorResponse(HTTP_STATUS.SERVICE_UNAVAILABLE, peek.message || CODEX_MODEL_CAPACITY_MESSAGE);
         return result;
       }
       if (attempt >= attempts) {
         args.log?.warn?.("RETRY", `CODEX | SSE overloaded "${peek.matched}" — retries exhausted (${attempt}/${attempts})`);
-        result.response = this._codexSseErrorResponse(HTTP_STATUS.SERVICE_UNAVAILABLE, peek.message || peek.matched);
+        result.response = codexSseErrorResponse(HTTP_STATUS.SERVICE_UNAVAILABLE, peek.message || peek.matched);
         return result;
       }
       attempt++;
@@ -788,153 +298,10 @@ export class CodexExecutor extends BaseExecutor {
     }
   }
 
-  async _executeWebSocket(args) {
-    const url = CODEX_RESPONSES_WS_URL;
-    const headers = normalizeCodexWsHeaders(this.buildHeaders(args.credentials, true));
-
-    // Merge extra headers if provided
-    if (args.upstreamExtraHeaders && typeof args.upstreamExtraHeaders === "object") {
-      for (const [k, v] of Object.entries(args.upstreamExtraHeaders)) {
-        if (typeof v === "string") headers[k] = v;
-      }
-    }
-
-    const transformedBody = await this.transformRequest(args.model, args.body, true, args.credentials);
-    transformedBody.model = getCodexUpstreamModel(transformedBody.model || args.model);
-    delete transformedBody.stream;
-    delete transformedBody.stream_options;
-
-    const bodyString = JSON.stringify({ type: "response.create", ...transformedBody });
-
-    const websocketFn = getCodexWebSocketTransport();
-    if (!websocketFn) {
-      return { response: codexWebSocketUnavailableResponse(), url, headers, transformedBody };
-    }
-
-    const encoder = new TextEncoder();
-    let closed = false;
-    let ws = null;
-    let streamController = null;
-
-    const closeUpstream = (reason) => {
-      try { ws?.close(1000, reason); } catch { /* ignore close races */ }
-    };
-
-    let abortHandler = null;
-    const removeAbortListener = () => {
-      if (!abortHandler) return;
-      args.signal?.removeEventListener("abort", abortHandler);
-      abortHandler = null;
-    };
-
-    const finishStream = ({ reason, emitDone = true, closeController = true, closeSocket = true }) => {
-      if (closed) return;
-      closed = true;
-      removeAbortListener();
-      if (closeSocket) closeUpstream(reason);
-      const controller = streamController;
-      if (!controller || !closeController) return;
-      if (emitDone) {
-        try { controller.enqueue(encoder.encode("data: [DONE]\n\n")); } catch { /* downstream may be gone */ }
-      }
-      try { controller.close(); } catch { /* controller may already be closed */ }
-    };
-
-    const failController = (code, message) => {
-      if (closed) return;
-      const controller = streamController;
-      const payload = JSON.stringify({
-        type: "response.failed",
-        response: { id: null, status: "failed", error: { code, message } },
-      });
-      try { controller?.enqueue(encoder.encode(`event: response.failed\ndata: ${payload}\n\n`)); } catch { /* downstream closed */ }
-      finishStream({ reason: "upstream_failed" });
-    };
-
-    const stream = new ReadableStream({
-      async start(controller) {
-        streamController = controller;
-        abortHandler = () => finishStream({ reason: "client_aborted" });
-        args.signal?.addEventListener("abort", abortHandler, { once: true });
-
-        try {
-          ws = await websocketFn(toWebSocketUrl(url), { browser: "chrome_142", os: "windows", headers });
-          if (closed) return;
-          if (args.signal?.aborted) { finishStream({ reason: "client_aborted" }); return; }
-
-          ws.onmessage = (event) => {
-            if (closed) return;
-            const raw = typeof event.data === "string"
-              ? event.data
-              : Buffer.from(event.data).toString("utf8");
-            const sseEvent = encodeResponseSseEvent(raw);
-            if (closed) return;
-            if (sseEvent.sse) {
-              try { controller.enqueue(encoder.encode(sseEvent.sse)); } catch {
-                finishStream({ reason: "downstream_closed", emitDone: false, closeController: false });
-                return;
-              }
-            }
-            if (sseEvent.terminal) finishStream({ reason: "terminal_event" });
-          };
-          ws.onerror = (event) => {
-            failController("upstream_websocket_error", event.message || "Codex upstream WebSocket error");
-          };
-          ws.onclose = () => {
-            finishStream({ reason: "upstream_closed", closeSocket: false });
-          };
-          if (!closed) {
-            await prl.captureCurrentProviderBody(url, headers, bodyString, args.log);
-            ws.send(bodyString);
-          }
-        } catch (error) {
-          failController("upstream_websocket_connect_failed", error instanceof Error ? error.message : String(error));
-        }
-      },
-      cancel() {
-        finishStream({ reason: "client_cancelled", emitDone: false, closeController: false });
-      },
-    });
-
-    return {
-      response: new Response(stream, {
-        status: 200,
-        headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" },
-      }),
-      url, headers, transformedBody,
-    };
-  }
-
-  // ── Prefetch remote images as base64 ──────────────────────────────────
-
-  async prefetchImages(body) {
-    if (!Array.isArray(body?.input)) return;
-    for (const item of body.input) {
-      if (!Array.isArray(item.content)) continue;
-      const pending = item.content.map(async (c) => {
-        if (c.type !== "image_url") return c;
-        const url = typeof c.image_url === "string" ? c.image_url : c.image_url?.url;
-        const detail = c.image_url?.detail || "auto";
-        if (!url) return c;
-        if (url.startsWith("data:")) return { type: "input_image", image_url: url, detail };
-        const fetched = await fetchImageAsBase64(url, { timeoutMs: 15000 });
-        return { type: "input_image", image_url: fetched?.url || url, detail };
-      });
-      item.content = await Promise.all(pending);
-    }
-  }
-
-  // ── SSE transient error peek ──────────────────────────────────────────
-
+  // Peek first N bytes of SSE body to detect upstream transient errors.
+  // Returns { matched: string|null, message: string|null, accountFallback: boolean, replacementBody: ReadableStream|null }.
+  // Caller must use replacementBody when no error matched (original body has been read).
   async _peekSseTransientError(response) {
-    const CODEX_SSE_RETRY_PATTERNS = ["server_is_overloaded", "service_unavailable_error"];
-    const CODEX_SSE_ACCOUNT_FALLBACK_PATTERNS = ["selected model is at capacity", "model_at_capacity"];
-    const CODEX_SSE_USER_OUTPUT_PATTERNS = [
-      "event: response.output_text.delta", "event: response.function_call_arguments.delta",
-      '"type":"response.output_text.delta"', '"type":"response.function_call_arguments.delta"',
-    ];
-    const CODEX_SSE_PEEK_BYTES = 256 * 1024;
-
     if (!response || !response.ok || !response.body) return { matched: null, message: null, accountFallback: false, replacementBody: null };
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
@@ -962,10 +329,12 @@ export class CodexExecutor extends BaseExecutor {
     if (matched) {
       try { await reader.cancel(); } catch { /* noop */ }
       try { reader.releaseLock(); } catch { /* noop */ }
-      return { matched, message: this._extractSseErrorMessage(text, matched), accountFallback, replacementBody: null };
+      return { matched, message: extractSseErrorMessage(text, matched), accountFallback, replacementBody: null };
     }
 
     reader.releaseLock();
+
+    // Re-assemble stream: prefix chunks + remaining upstream body
     const upstream = response.body;
     let upstreamReader = null;
     const replacementBody = new ReadableStream({
@@ -987,145 +356,7 @@ export class CodexExecutor extends BaseExecutor {
     return { matched: null, message: null, accountFallback: false, replacementBody };
   }
 
-  _extractSseErrorMessage(text, fallback) {
-    const exact = text?.match(/Selected model is at capacity\. Please try a different model\./i)?.[0];
-    if (exact) return exact;
-    for (const line of String(text || "").split(/\r?\n/)) {
-      if (!line.startsWith("data:")) continue;
-      const data = line.slice(5).trim();
-      if (!data || data === "[DONE]") continue;
-      try {
-        const parsed = JSON.parse(data);
-        const message = this._findNestedMessage(parsed);
-        if (message) return message;
-      } catch { /* Ignore non-JSON */ }
-    }
-    return fallback || "Selected model is at capacity. Please try a different model.";
-  }
-
-  _findNestedMessage(value, depth = 0) {
-    if (!value || depth > 6 || typeof value === "string") return null;
-    if (Array.isArray(value)) {
-      for (const item of value) { const f = this._findNestedMessage(item, depth + 1); if (f) return f; }
-      return null;
-    }
-    if (typeof value !== "object") return null;
-    if (typeof value.message === "string" && value.message.trim()) return value.message;
-    if (typeof value.error?.message === "string" && value.error.message.trim()) return value.error.message;
-    if (typeof value.response?.error?.message === "string" && value.response.error.message.trim()) return value.response.error.message;
-    for (const child of Object.values(value)) { const f = this._findNestedMessage(child, depth + 1); if (f) return f; }
-    return null;
-  }
-
-  _codexSseErrorResponse(status, message) {
-    return new Response(JSON.stringify({
-      error: {
-        message,
-        type: status >= 500 ? "server_error" : "invalid_request_error",
-        code: status === HTTP_STATUS.SERVICE_UNAVAILABLE ? "service_unavailable" : "upstream_error",
-      },
-    }), { status, headers: { "Content-Type": "application/json" } });
-  }
-
-  // ── Header / URL builders ─────────────────────────────────────────────
-
-  buildUrl(model, stream, urlIndex = 0, credentials = null) {
-    const responsesSubpath = getResponsesSubpath(credentials?.requestEndpointPath);
-    if (responsesSubpath !== null) {
-      const baseUrl = String(this.config.baseUrl || "").replace(/\/$/, "");
-      if (baseUrl.endsWith("/responses")) return `${baseUrl}${responsesSubpath}`;
-      return `${baseUrl}/responses${responsesSubpath}`;
-    }
-    if (this._isCompact) {
-      const base = super.buildUrl(model, stream, urlIndex, credentials);
-      return `${base}/compact`;
-    }
-    return super.buildUrl(model, stream, urlIndex, credentials);
-  }
-
-  buildHeaders(credentials, stream = true) {
-    const isCompactRequest = isCompactResponsesEndpoint(credentials?.requestEndpointPath);
-    const headers = super.buildHeaders(credentials, isCompactRequest ? false : true);
-
-    // Codex client version + user agent
-    headers["Version"] = getCodexClientVersion();
-    headers["User-Agent"] = getCodexUserAgent();
-
-    // Workspace binding header
-    const workspaceId = credentials?.providerSpecificData?.workspaceId;
-    if (typeof workspaceId === "string" && workspaceId) {
-      headers["chatgpt-account-id"] = workspaceId;
-    }
-
-    // Also support chatgptAccountId / accountId as fallback
-    const accountId = credentials?.providerSpecificData?.chatgptAccountId || credentials?.providerSpecificData?.accountId;
-    if (typeof accountId === "string" && accountId && !headers["chatgpt-account-id"]) {
-      headers["chatgpt-account-id"] = accountId;
-    }
-
-    // Originator header — identifies the client type to Codex backend
-    if (!headers["originator"]) headers["originator"] = "codex_cli_rs";
-
-    // Session ID for prompt cache affinity
-    const cacheSessionId = this.getPromptCacheSessionId(credentials, null);
-    if (cacheSessionId) headers["session_id"] = cacheSessionId;
-
-    // Client identity headers
-    const clientIdentity = credentials?.providerSpecificData?.codexClientIdentity;
-    applyCodexClientIdentityHeaders(headers, clientIdentity);
-
-    return headers;
-  }
-
-  // ── Prompt cache session ID ───────────────────────────────────────────
-
-  getPromptCacheSessionId(credentials, body) {
-    const promptCacheKey = normalizeCodexSessionId(body?.prompt_cache_key);
-    if (promptCacheKey) return promptCacheKey;
-
-    const sessionId = body?.session_id ?? body?.conversation_id;
-    const normalizedSessionId = normalizeCodexSessionId(sessionId);
-    if (normalizedSessionId) return normalizedSessionId;
-
-    // AMRouter: use resolveSessionId for stable session IDs
-    if (credentials) {
-      return resolveCacheSessionId(body || {}, credentials);
-    }
-    return normalizeCodexSessionId(credentials?.providerSpecificData?.workspaceId) || null;
-  }
-
-  // ── Credential refresh ────────────────────────────────────────────────
-
-  async refreshCredentials(credentials, log) {
-    if (!credentials?.refreshToken) {
-      log?.warn?.("TOKEN_REFRESH", "Codex: no refresh token available, re-authentication required");
-      return null;
-    }
-    // Try AMRouter's refreshProviderCredentials first
-    try {
-      const result = await refreshProviderCredentials("codex", credentials, log);
-      if (result) return result;
-    } catch { /* fall through to getAccessToken */ }
-
-    // Fallback to getAccessToken
-    const result = await getAccessToken("codex", credentials, log);
-    if (!result) {
-      log?.warn?.("TOKEN_REFRESH", "Codex: token refresh failed — re-authentication required");
-      return null;
-    }
-    if (result.error) {
-      log?.warn?.("TOKEN_REFRESH", `Codex: token refresh failed (${result.error}) — re-authentication required`);
-      return null;
-    }
-    return result;
-  }
-
-  needsRefresh(credentials) {
-    return shouldRefreshCredentials("codex", credentials);
-  }
-
-  // ── Parse 429 with usage_limit_reached ────────────────────────────────
-
+  // Parse Codex usage_limit_reached to extract precise resetsAtMs; fallback to default otherwise
   parseError(response, bodyText) {
     if (response.status === 429 && bodyText) {
       try {
@@ -1141,144 +372,88 @@ export class CodexExecutor extends BaseExecutor {
           if (!resetsAtMs && typeof err.resets_in_seconds === "number" && err.resets_in_seconds > 0) {
             resetsAtMs = now + err.resets_in_seconds * 1000;
           }
-          if (resetsAtMs) return { status: 429, message: err.message || bodyText, resetsAtMs };
+          if (resetsAtMs) {
+            return { status: 429, message: err.message || bodyText, resetsAtMs };
+          }
         }
-      } catch { /* fall through */ }
+      } catch { /* fall through to default */ }
     }
     return super.parseError(response, bodyText);
   }
 
-  // ── Transform request (main business logic) ───────────────────────────
-
-  transformRequest(model, bodyInput, stream, credentials) {
-    this._isCompact = !!bodyInput?._compact;
-    // Do not mutate the caller's payload in place
-    const body = bodyInput && typeof bodyInput === "object"
-      ? structuredClone(bodyInput)
-      : {};
-
-    const nativeCodexPassthrough = body?._nativeCodexPassthrough === true;
-    const isCompactRequest = isCompactResponsesEndpoint(credentials?.requestEndpointPath);
-    const requestDefaults = getCodexRequestDefaults(credentials?.providerSpecificData);
-    const thinkingBudgetConfig = getThinkingBudgetConfig();
-    const allowConnectionReasoningDefaults = thinkingBudgetConfig.mode === ThinkingMode.PASSTHROUGH;
-    consumeResponsesStoreMarker(body);
-
-    // Resolve conversation-stable session_id
-    this._currentSessionId = this.getPromptCacheSessionId(credentials, body);
-
-    // Codex /responses rejects stream=false, but /responses/compact rejects the stream field entirely
-    if (isCompactRequest) {
-      delete body.stream;
-      delete body.stream_options;
-      delete body.client_metadata;
-    } else {
-      body.stream = true;
-    }
-    delete body._nativeCodexPassthrough;
+  /**
+   * Transform request before sending - inject default instructions if missing.
+   * Image fetching is handled separately in prefetchImages() so this stays sync.
+   */
+  transformRequest(model, body, stream, credentials) {
+    this._isCompact = !!body._compact;
     delete body._compact;
-
-    const requestServiceTier = normalizeServiceTierValue(body.service_tier);
-    if (requestServiceTier) {
-      body.service_tier = requestServiceTier;
-    } else if (requestDefaults.serviceTier) {
-      body.service_tier = requestDefaults.serviceTier;
-    }
-
-    // Messages/prompt → input conversion (must run before role conversion + strip)
-    normalizeCodexResponsesInput(body);
-
-    // Normalize string input to array format
+    // Resolve conversation-stable session_id (priority: body → assistant-text → workspace → machine)
+    this._currentSessionId = resolveCacheSessionId(body, credentials);
+    // Convert string input to array format (Codex API requires input as array)
     const normalized = normalizeResponsesInput(body.input);
     if (normalized) body.input = normalized;
 
-    // Ensure input is present and non-empty
+    // Ensure input is present and non-empty (Codex API rejects empty input)
     if (!body.input || (Array.isArray(body.input) && body.input.length === 0)) {
-      body.input = [{ type: "message", role: "user", content: [{ type: "input_text", text: "continue" }] }];
+      body.input = [{ type: "message", role: "user", content: [{ type: "input_text", text: "..." }] }];
     }
 
-    if (Array.isArray(body.input)) {
-      body.input = sanitizeResponsesInputItems(body.input, false, {
-        dropInternalAssistantMessages: !nativeCodexPassthrough,
-      });
-    }
-    repairMissingCodexFunctionCallOutputs(body);
-
-    // Cache-aware system → developer role conversion
+    // Keep system prompts in body.input as role=developer so they stay in the cacheable prefix
     convertSystemToDeveloperRole(body);
+    // Strip server-generated item IDs (rs_/fc_/resp_/msg_) — Codex /responses can't resolve when store=false
+    stripStoredItemReferences(body);
+    // Flatten function tools + drop unsupported types
+    normalizeCodexTools(body);
 
-    if (nativeCodexPassthrough) {
-      if (!body.instructions || (typeof body.instructions === "string" && body.instructions.trim() === "")) {
-        body.instructions = "Follow the developer instructions in the conversation.";
-      }
-    } else {
-      const hasTools = Array.isArray(body.tools) && body.tools.length > 0;
-      if (!body.instructions || (typeof body.instructions === "string" && body.instructions.trim() === "")) {
-        body.instructions = hasTools ? CODEX_DEFAULT_INSTRUCTIONS : CODEX_CHAT_DEFAULT_INSTRUCTIONS;
-      }
-    }
+    // Ensure streaming is enabled (Codex API requires it)
+    body.stream = true;
 
-    // Store: regular Codex rejects store=true; compact rejects the field entirely
-    const explicitStoreSetting = credentials?.providerSpecificData?.openaiStoreEnabled;
-    if (isCompactRequest) {
-      delete body.store;
-    } else if (explicitStoreSetting === true) {
-      body.store = true;
-    } else {
-      body.store = false;
+    // If no instructions provided, inject default Codex instructions
+    if (!body.instructions || body.instructions.trim() === "") {
+      body.instructions = CODEX_DEFAULT_INSTRUCTIONS;
     }
 
-    // Normalize tools (hosted tool passthrough, free-plan gating)
-    normalizeCodexTools(body, {
-      dropImageGeneration: isCodexFreePlan(credentials?.providerSpecificData),
-      preserveCustomTools: nativeCodexPassthrough,
-    });
-
-    // Strip stored item references
-    stripStoredItemReferences(body);
+    // Ensure store is false (Codex requirement)
+    body.store = false;
 
-    // Clean up messages/prompt fields
-    delete body.messages;
-    delete body.prompt;
-
-    // Map virtual Codex review models to upstream
-    if (typeof body.model === "string") {
-      body.model = getModelUpstreamId("cx", body.model) || body.model;
+    // Inject prompt_cache_key for stable Codex prompt caching
+    if (!body.prompt_cache_key && this._currentSessionId) {
+      body.prompt_cache_key = this._currentSessionId;
     }
 
+    // Map virtual Codex review models to the upstream Codex model before suffix parsing.
+    body.model = getModelUpstreamId("cx", body.model || model);
+
     // Extract thinking level from model name suffix
+    // e.g., gpt-5.3-codex-high → high, gpt-5.3-codex → medium (default)
+    const effortLevels = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh'];
     let modelEffort = null;
-    let cleanModel = typeof body.model === "string" ? body.model : model;
-    const splitModel = splitCodexReasoningSuffix(cleanModel);
-    if (splitModel.effort) {
-      modelEffort = splitModel.effort;
-      body.model = splitModel.baseModel;
-      cleanModel = splitModel.baseModel;
+    for (const level of effortLevels) {
+      if (body.model.endsWith(`-${level}`)) {
+        modelEffort = level;
+        // Strip suffix from model name for actual API call
+        body.model = body.model.replace(`-${level}`, '');
+        break;
+      }
     }
 
-    // Reasoning effort: model suffix > explicit reasoning.effort > reasoning_effort > defaults
-    const reasoningRecord = body.reasoning && typeof body.reasoning === "object" && !Array.isArray(body.reasoning)
-      ? body.reasoning : null;
-    const explicitReasoning = normalizeEffortValue(reasoningRecord?.effort);
-    const requestReasoningEffort = normalizeEffortValue(body.reasoning_effort);
-    const fallbackReasoningEffort = allowConnectionReasoningDefaults
-      ? requestDefaults.reasoningEffort || "medium" : undefined;
-    const rawEffort = modelEffort || explicitReasoning || requestReasoningEffort || fallbackReasoningEffort;
-
-    if (rawEffort) {
-      body.reasoning = { ...(reasoningRecord || {}), effort: clampEffort(cleanModel, rawEffort) };
+    // Priority: explicit reasoning.effort > reasoning_effort param > model suffix > default (medium)
+    if (!body.reasoning) {
+      const effort = normalizeReasoningEffort(body.reasoning_effort || modelEffort || 'low');
+      body.reasoning = { effort, summary: "auto" };
+    } else {
+      body.reasoning.effort = normalizeReasoningEffort(body.reasoning.effort);
+      if (!body.reasoning.summary) body.reasoning.summary = "auto";
     }
-    ensureCodexReasoningSummary(body);
     delete body.reasoning_effort;
 
-    // Remove unsupported parameters
-    delete body.max_tokens;
-    delete body.max_output_tokens;
-    delete body.truncation;
-    delete body.background;
-    delete body.prompt_cache_retention;
-    delete body.safety_identifier;
-    delete body.user;
+    // Include reasoning encrypted content (required by Codex backend for reasoning models)
+    if (body.reasoning && body.reasoning.effort && body.reasoning.effort !== 'none') {
+      body.include = ["reasoning.encrypted_content"];
+    }
+
+    // Remove unsupported parameters for Codex API
     delete body.temperature;
     delete body.top_p;
     delete body.frequency_penalty;
@@ -1287,38 +462,24 @@ export class CodexExecutor extends BaseExecutor {
     delete body.top_logprobs;
     delete body.n;
     delete body.seed;
+    delete body.max_tokens;
     delete body.max_completion_tokens;
-    delete body.metadata;
-    delete body.stream_options;
+    delete body.max_output_tokens; // Responses API clients send this but Codex rejects it
+    delete body.user; // Cursor sends this but Codex doesn't support it
+    delete body.prompt_cache_retention; // Cursor sends this but Codex doesn't support it
+    delete body.metadata; // Cursor sends this but Codex doesn't support it
+    delete body.stream_options; // Cursor sends this but Codex doesn't support it
+    delete body.safety_identifier; // Droid CLI sends this but Codex doesn't support it
+    delete body.previous_response_id; // store=false → backend can't resolve previous resp; avoid 404
 
-    // Inject prompt_cache_key for Codex prompt caching
-    if (!body.prompt_cache_key) {
-      const cacheSessionId = this.getPromptCacheSessionId(credentials, body);
-      if (cacheSessionId) body.prompt_cache_key = cacheSessionId;
-    }
-    if (!isCompactRequest) {
-      applyCodexClientMetadata(body, credentials?.providerSpecificData?.codexClientIdentity);
-    }
+    if (body.service_tier === "fast") body.service_tier = "priority";
+    if (body.service_tier && body.service_tier !== "priority") delete body.service_tier;
 
-    // Delete session_id and conversation_id from body (unsupported upstream)
-    delete body.session_id;
-    delete body.conversation_id;
-
-    // previous_response_id: store=false → backend can't resolve; avoid 404
-    delete body.previous_response_id;
-
-    if (nativeCodexPassthrough) return body;
-
-    // GPT-5 verbosity normalization
-    normalizeCodexVerbosity(body);
-
-    // Final allowlist filter — strip unknown fields
-    for (const key of Object.keys(body)) {
-      if (!RESPONSES_API_ALLOWLIST.has(key)) delete body[key];
+    // Final allowlist filter — strip any unknown field that could trigger upstream "routing_unsupported"
+    for (const k of Object.keys(body)) {
+      if (!RESPONSES_API_ALLOWLIST.has(k)) delete body[k];
     }
 
     return body;
   }
 }
-
-export default CodexExecutor;