#!/usr/bin/env node

import http from "node:http";
import { spawn } from "node:child_process";
import { createHash } from "node:crypto";
import { chmod, copyFile, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
import fs from "node:fs";
import path from "node:path";
import { DatabaseSync } from "node:sqlite";
import zlib from "node:zlib";
import { TextDecoder } from "node:util";
import { fileURLToPath } from "node:url";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const ADMIN_BASE_PATH = "/__codex_retry_gateway";
const UI_PATH = `${ADMIN_BASE_PATH}/ui`;
const UI_STATIC_ROOT = path.join(__dirname, "public", "ui");
const STATUS_API_PATH = `${ADMIN_BASE_PATH}/api/status`;
const CONFIG_API_PATH = `${ADMIN_BASE_PATH}/api/config`;
const LOGS_API_PATH = `${ADMIN_BASE_PATH}/api/logs`;
const REQUESTS_API_PATH = `${ADMIN_BASE_PATH}/api/requests`;
const THREAD_RULES_API_PATH = `${ADMIN_BASE_PATH}/api/thread-rules`;
const THREAD_RULE_ITEM_API_PREFIX = `${THREAD_RULES_API_PATH}/`;
const PROFILES_API_PATH = `${ADMIN_BASE_PATH}/api/profiles`;
const PROFILE_PROBE_API_PATH = `${ADMIN_BASE_PATH}/api/profiles/probe`;
const PROFILE_SWITCH_API_PATH = `${ADMIN_BASE_PATH}/api/profiles/switch`;
const PROFILE_ITEM_API_PREFIX = `${ADMIN_BASE_PATH}/api/profiles/`;
const IMAGE_PROFILES_API_PATH = `${ADMIN_BASE_PATH}/api/image-profiles`;
const IMAGE_PROFILE_PROBE_API_PATH = `${ADMIN_BASE_PATH}/api/image-profiles/probe`;
const IMAGE_PROFILE_SWITCH_API_PATH = `${ADMIN_BASE_PATH}/api/image-profiles/switch`;
const IMAGE_PROFILE_ITEM_API_PREFIX = `${ADMIN_BASE_PATH}/api/image-profiles/`;
const RESTORE_API_PATH = `${ADMIN_BASE_PATH}/api/restore`;
const STATUS_REASONING_COUNT_LIMIT = 24;
const MANAGEMENT_ACCESS_COOKIE = "codex_retry_gateway_access";
const RESPONSES_REASONING_RETRY_PATHS = new Set(["/responses", "/v1/responses"]);
const REASONING_RETRY_ABORT_CLIENT = "reasoning_retry_client_disconnected";
const REASONING_RETRY_ABORT_WINNER = "reasoning_retry_winner_selected";

const DEFAULT_CONFIG = {
  profile_name: "default",
  image_profile_name: "",
  listen_host: "127.0.0.1",
  listen_port: 4610,
  upstream_base_url: "",
  upstream_auth_mode: "passthrough",
  upstream_auth_env: "CODEX_RETRY_GATEWAY_UPSTREAM_API_KEY",
  upstream_auth_file: "",
  upstream_auth_json_path: "",
  upstream_auth_json_key: "OPENAI_API_KEY",
  image_base_url: "",
  image_auth_mode: "fixed_bearer",
  image_auth_env: "CODEX_RETRY_GATEWAY_IMAGE_API_KEY",
  image_auth_file: "",
  image_auth_json_path: "",
  image_auth_json_key: "OPENAI_API_KEY",
  request_body_limit_bytes: 1024 * 1024 * 1024,
  request_history_limit: 0,
  model_remap: "",
  endpoints: ["/responses", "/chat/completions", "/v1/responses", "/v1/chat/completions"],
  reasoning_match_mode: "formula_518n_minus_2",
  reasoning_equals: [516, 1034, 1552],
  retryable_status_codes: [429, 503],
  retryable_error_messages: [
    "Selected model is at capacity. Please try a different model.",
    "stream disconnected before completion: Concurrency limit exceeded for account, please retry later",
  ],
  management_access_key: "",
  upstream_fetch_retry_attempts: 5,
  upstream_fetch_retry_backoff_ms: 350,
  non_stream_status_code: 502,
  stream_action: "strict_502",
  log_match: true,
  health_path: "/__codex_retry_gateway/health",
};

const REASONING_POINTERS = [
  "/usage/output_tokens_details/reasoning_tokens",
  "/usage/completion_tokens_details/reasoning_tokens",
  "/response/usage/output_tokens_details/reasoning_tokens",
  "/response/usage/completion_tokens_details/reasoning_tokens",
];
const REQUEST_THREAD_ID_POINTERS = [
  "/thread_id",
  "/client_metadata/thread_id",
  "/client_metadata/x-codex-thread-id",
  "/thread",
  "/thread/id",
  "/threadId",
  "/client_metadata/threadId",
  "/conversation_id",
  "/conversationId",
  "/conversation",
  "/conversation/id",
  "/metadata/thread_id",
  "/metadata/threadId",
  "/metadata/conversation_id",
  "/metadata/conversationId",
  "/x-codex-turn-metadata/thread_id",
  "/x-codex-turn-metadata/threadId",
  "/x-codex-turn-metadata/conversation_id",
  "/x-codex-turn-metadata/conversationId",
  "/previous_response_id",
];
const REQUEST_REASONING_EFFORT_POINTERS = [
  "/reasoning/effort",
  "/reasoning_effort",
  "/reasoningEffort",
];
const REQUEST_REASONING_SUMMARY_POINTERS = [
  "/reasoning/summary",
  "/reasoning_summary",
  "/reasoningSummary",
];
const RESPONSE_THREAD_ID_POINTERS = [
  "/thread_id",
  "/client_metadata/thread_id",
  "/client_metadata/x-codex-thread-id",
  "/thread",
  "/thread/id",
  "/threadId",
  "/client_metadata/threadId",
  "/conversation_id",
  "/conversationId",
  "/conversation",
  "/conversation/id",
  "/response/thread_id",
  "/response/threadId",
  "/response/thread",
  "/response/thread/id",
  "/response/conversation_id",
  "/response/conversationId",
  "/response/conversation",
  "/response/conversation/id",
];
const NON_STREAM_RESPONSE_ID_POINTERS = [
  "/id",
  "/response_id",
  "/response/id",
];
const STREAM_RESPONSE_ID_POINTERS = [
  "/response_id",
  "/response/id",
];

function parseArgs(argv) {
  const args = { config: null, log: null };
  for (let i = 2; i < argv.length; i += 1) {
    const current = argv[i];
    if (current === "--config") {
      args.config = argv[i + 1];
      i += 1;
    } else if (current === "--log") {
      args.log = argv[i + 1];
      i += 1;
    } else if (current === "--help" || current === "-h") {
      printHelp();
      process.exit(0);
    }
  }
  return args;
}

function printHelp() {
  process.stdout.write(
    [
      "用法:",
      "  node gateway.mjs --config <config.json> [--log <gateway.log>]",
      "",
      "说明:",
      "  独立 Codex 本地重试网关。",
      "  默认按 518n-2 公式拦截 reasoning_tokens（516, 1034, 1552, ...），非流式返回 502。",
      "  流式命中时默认缓存并返回 502，避免半截流返回。",
      "",
    ].join("\n"),
  );
}

function normalizePath(inputPath) {
  const [withoutQuery] = `${inputPath || "/"}`.split("?");
  const trimmed = withoutQuery.length > 1 ? withoutQuery.replace(/\/+$/, "") : withoutQuery;
  return trimmed || "/";
}

function expandEscapedLineBreaks(value) {
  return `${value ?? ""}`
    .replace(/\\r\\n/g, "\n")
    .replace(/\\n/g, "\n")
    .replace(/\\r/g, "\n");
}

function flattenValues(value) {
  if (Array.isArray(value)) {
    return value.flatMap((item) => flattenValues(item));
  }
  return [value];
}

function isJsonContentType(contentType) {
  return `${contentType || ""}`.toLowerCase().includes("application/json");
}

function isSseContentType(contentType) {
  return `${contentType || ""}`.toLowerCase().includes("text/event-stream");
}

function jsonPointerGet(value, pointer) {
  if (!pointer.startsWith("/")) {
    return undefined;
  }
  return pointer
    .slice(1)
    .split("/")
    .map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~"))
    .reduce((current, segment) => {
      if (current === null || current === undefined) {
        return undefined;
      }
      return current[segment];
    }, value);
}

function extractReasoningTokens(payload) {
  for (const pointer of REASONING_POINTERS) {
    const raw = jsonPointerGet(payload, pointer);
    if (Number.isInteger(raw)) {
      return raw;
    }
  }
  return null;
}

function firstInteger(...values) {
  for (const value of values) {
    if (Number.isInteger(value)) {
      return value;
    }
  }
  return null;
}

function firstNonEmptyString(...values) {
  for (const value of values) {
    if (typeof value !== "string") {
      continue;
    }
    const trimmed = value.trim();
    if (trimmed) {
      return trimmed;
    }
  }
  return null;
}

function timingSafeEquals(left, right) {
  const leftText = Buffer.from(`${left || ""}`);
  const rightText = Buffer.from(`${right || ""}`);
  if (leftText.length !== rightText.length) {
    return false;
  }
  let mismatch = 0;
  for (let i = 0; i < leftText.length; i += 1) {
    mismatch |= leftText[i] ^ rightText[i];
  }
  return mismatch === 0;
}

function parseCookieHeader(cookieHeader) {
  const cookies = {};
  for (const part of `${cookieHeader || ""}`.split(";")) {
    const trimmed = part.trim();
    if (!trimmed) {
      continue;
    }
    const separatorIndex = trimmed.indexOf("=");
    if (separatorIndex <= 0) {
      continue;
    }
    const key = trimmed.slice(0, separatorIndex).trim();
    const value = trimmed.slice(separatorIndex + 1).trim();
    cookies[key] = value;
  }
  return cookies;
}

function normalizeManagementAccessKey(value) {
  return `${value || ""}`.trim();
}

function currentManagementAccessKey(config) {
  return normalizeManagementAccessKey(config?.management_access_key);
}

function managementAccessEnabled(config) {
  return Boolean(currentManagementAccessKey(config));
}

function requestManagementAccessKey(req, requestUrl) {
  const headerKey = firstNonEmptyString(
    req.headers["x-codex-retry-gateway-key"],
    req.headers["x-codex-retry-gateway-access-key"],
    req.headers.authorization?.startsWith?.("Bearer ")
      ? req.headers.authorization.slice("Bearer ".length)
      : null,
  );
  if (headerKey) {
    return headerKey;
  }
  const queryKey = firstNonEmptyString(
    requestUrl?.searchParams?.get("key"),
    requestUrl?.searchParams?.get("access_key"),
  );
  if (queryKey) {
    return queryKey;
  }
  const cookies = parseCookieHeader(req.headers.cookie || "");
  return firstNonEmptyString(cookies[MANAGEMENT_ACCESS_COOKIE]);
}

function hasManagementAccess(req, requestUrl, config) {
  const expected = currentManagementAccessKey(config);
  if (!expected) {
    return true;
  }
  const provided = requestManagementAccessKey(req, requestUrl);
  return Boolean(provided) && timingSafeEquals(provided, expected);
}

function clearManagementAccessCookieHeaders() {
  return [
    `${MANAGEMENT_ACCESS_COOKIE}=; Path=${ADMIN_BASE_PATH}; HttpOnly; SameSite=Lax; Max-Age=0`,
  ];
}

function buildManagementAccessCookieHeaders(config, accessKey) {
  const expected = currentManagementAccessKey(config);
  if (!expected || !accessKey || !timingSafeEquals(accessKey, expected)) {
    return clearManagementAccessCookieHeaders();
  }
  return [
    `${MANAGEMENT_ACCESS_COOKIE}=${accessKey}; Path=${ADMIN_BASE_PATH}; HttpOnly; SameSite=Lax`,
  ];
}

function managementUnauthorizedPayload() {
  return {
    error: {
      message: "management access key required",
      code: "management_access_key_required",
    },
  };
}

function extractStringByPointers(payload, pointers) {
  for (const pointer of pointers) {
    const raw = jsonPointerGet(payload, pointer);
    if (typeof raw !== "string") {
      continue;
    }
    const trimmed = raw.trim();
    if (trimmed) {
      return trimmed;
    }
  }
  return null;
}

function extractRequestThreadId(payload) {
  return extractStringByPointers(payload, REQUEST_THREAD_ID_POINTERS);
}

function extractRequestReasoningEffort(payload) {
  return extractStringByPointers(payload, REQUEST_REASONING_EFFORT_POINTERS);
}

function extractRequestReasoningSummary(payload) {
  return extractStringByPointers(payload, REQUEST_REASONING_SUMMARY_POINTERS);
}

function extractResponseThreadId(payload) {
  return extractStringByPointers(payload, RESPONSE_THREAD_ID_POINTERS);
}

function extractHeaderThreadId(headers) {
  if (!headers || typeof headers !== "object") {
    return null;
  }
  const candidates = [
    "thread-id",
    "x-client-request-id",
    "conversation_id",
    "conversation-id",
    "session_id",
    "session-id",
    "x-codex-parent-thread-id",
  ];
  for (const key of candidates) {
    const raw = headers[key];
    if (Array.isArray(raw)) {
      for (const item of raw) {
        const text = firstNonEmptyString(item);
        if (text) {
          return text;
        }
      }
      continue;
    }
    const text = firstNonEmptyString(raw);
    if (text) {
      return text;
    }
  }
  return null;
}

function extractNonStreamingResponseId(payload) {
  return extractStringByPointers(payload, NON_STREAM_RESPONSE_ID_POINTERS);
}

function extractStreamingResponseId(payload) {
  return extractStringByPointers(payload, STREAM_RESPONSE_ID_POINTERS);
}

function normalizeUsageSnapshot(payload) {
  const usage = payload?.usage || payload?.response?.usage || null;
  if (!usage || typeof usage !== "object") {
    return null;
  }

  const inputTokens = firstInteger(usage.input_tokens, usage.prompt_tokens);
  const outputTokens = firstInteger(usage.output_tokens, usage.completion_tokens);
  const totalTokens = firstInteger(
    usage.total_tokens,
    inputTokens !== null && outputTokens !== null ? inputTokens + outputTokens : null,
  );
  const reasoningTokens = firstInteger(
    usage.output_tokens_details?.reasoning_tokens,
    usage.completion_tokens_details?.reasoning_tokens,
    payload?.response?.usage?.output_tokens_details?.reasoning_tokens,
    payload?.response?.usage?.completion_tokens_details?.reasoning_tokens,
  );
  const cachedTokens = firstInteger(
    usage.input_tokens_details?.cached_tokens,
    usage.prompt_tokens_details?.cached_tokens,
    payload?.response?.usage?.input_tokens_details?.cached_tokens,
    payload?.response?.usage?.prompt_tokens_details?.cached_tokens,
  );

  if (
    inputTokens === null &&
    outputTokens === null &&
    totalTokens === null &&
    reasoningTokens === null &&
    cachedTokens === null
  ) {
    return null;
  }

  return {
    input_tokens: inputTokens,
    output_tokens: outputTokens,
    total_tokens: totalTokens,
    reasoning_tokens: reasoningTokens,
    cached_tokens: cachedTokens,
  };
}

function mergeUsageSnapshots(current, next) {
  if (!next) {
    return current || null;
  }
  return {
    input_tokens: next.input_tokens ?? current?.input_tokens ?? null,
    output_tokens: next.output_tokens ?? current?.output_tokens ?? null,
    total_tokens: next.total_tokens ?? current?.total_tokens ?? null,
    reasoning_tokens: next.reasoning_tokens ?? current?.reasoning_tokens ?? null,
    cached_tokens: next.cached_tokens ?? current?.cached_tokens ?? null,
  };
}

function sumUsageSnapshots(current, next) {
  if (!next) {
    return current || null;
  }
  const result = { ...(current || {}) };
  for (const key of ["input_tokens", "output_tokens", "total_tokens", "reasoning_tokens", "cached_tokens"]) {
    const nextValue = next[key];
    if (!Number.isInteger(nextValue)) {
      continue;
    }
    result[key] = (Number.isInteger(result[key]) ? result[key] : 0) + nextValue;
  }
  return Object.keys(result).length > 0 ? result : null;
}

function denormalizeUsageSnapshotToResponsesUsage(usage) {
  if (!usage || typeof usage !== "object") {
    return null;
  }
  const payload = {};
  if (Number.isInteger(usage.input_tokens)) {
    payload.input_tokens = usage.input_tokens;
  }
  if (Number.isInteger(usage.output_tokens)) {
    payload.output_tokens = usage.output_tokens;
  }
  if (Number.isInteger(usage.total_tokens)) {
    payload.total_tokens = usage.total_tokens;
  } else if (Number.isInteger(usage.input_tokens) && Number.isInteger(usage.output_tokens)) {
    payload.total_tokens = usage.input_tokens + usage.output_tokens;
  }
  if (Number.isInteger(usage.cached_tokens)) {
    payload.input_tokens_details = {
      cached_tokens: usage.cached_tokens,
    };
  }
  if (Number.isInteger(usage.reasoning_tokens)) {
    payload.output_tokens_details = {
      reasoning_tokens: usage.reasoning_tokens,
    };
  }
  return Object.keys(payload).length > 0 ? payload : null;
}

function cloneJsonLike(value) {
  if (value === null || value === undefined) {
    return value;
  }
  return JSON.parse(JSON.stringify(value));
}

function buildSseBlock(eventName, payloadText) {
  const lines = [];
  if (`${eventName || ""}`.trim()) {
    lines.push(`event: ${`${eventName}`.trim()}`);
  }
  lines.push(`data: ${payloadText}`);
  return Buffer.from(`${lines.join("\n")}\n\n`);
}

const RESPONSES_MODEL_HEADER_NAMES = new Set(["openai-model", "x-openai-model"]);

function normalizeResponsesHeaderSubset(...sources) {
  const headers = {};
  for (const source of sources) {
    if (!source || typeof source !== "object" || Array.isArray(source)) {
      continue;
    }
    for (const [key, value] of Object.entries(source)) {
      if (!RESPONSES_MODEL_HEADER_NAMES.has(`${key}`.toLowerCase())) {
        continue;
      }
      headers[key] = cloneJsonLike(value);
    }
  }
  return Object.keys(headers).length > 0 ? headers : null;
}

function createEmptySseInspectionResult() {
  return {
    reasoning: null,
    usage: null,
    response_id: null,
    thread_id: null,
    retryable_upstream_error: null,
  };
}

function mergeSseInspectionResult(target, next) {
  if (Number.isInteger(next.reasoning)) {
    target.reasoning = next.reasoning;
  }
  target.usage = mergeUsageSnapshots(target.usage, next.usage);
  target.response_id = target.response_id || next.response_id || null;
  target.thread_id = target.thread_id || next.thread_id || null;
  target.retryable_upstream_error = next.retryable_upstream_error || target.retryable_upstream_error || null;
  return target;
}

function inspectSseBlocks(blocks, config) {
  const result = createEmptySseInspectionResult();
  for (const block of blocks) {
    const lines = `${block || ""}`
      .split(/\r?\n/)
      .map((line) => line.trimEnd())
      .filter(Boolean);
    const eventName = lines
      .filter((line) => line.startsWith("event:"))
      .map((line) => line.replace(/^event:\s?/, "").trim())
      .find(Boolean) || "";
    const dataLines = lines
      .filter((line) => line.startsWith("data:"))
      .map((line) => line.replace(/^data:\s?/, ""));

    if (dataLines.length === 0) {
      continue;
    }
    const payloadText = dataLines.join("\n");
    if (payloadText === "[DONE]") {
      continue;
    }
    let parsed = null;
    try {
      parsed = JSON.parse(payloadText);
      const reasoning = extractReasoningTokens(parsed);
      if (reasoning !== null) {
        result.reasoning = reasoning;
      }
      result.usage = mergeUsageSnapshots(result.usage, normalizeUsageSnapshot(parsed));
      result.response_id = result.response_id || extractStreamingResponseId(parsed) || extractNonStreamingResponseId(parsed);
      result.thread_id = result.thread_id || extractResponseThreadId(parsed);
    } catch {
      // ignore malformed SSE payloads
    }
    const retryableUpstreamError = findRetryableStreamErrorMatch(
      config,
      parsed,
      payloadText,
      eventName,
    );
    if (retryableUpstreamError) {
      result.retryable_upstream_error = retryableUpstreamError;
    }
  }
  return result;
}

function flushSseInspectionRemainder(state, config) {
  if (!state?.buffer || !state.buffer.trim()) {
    state.buffer = "";
    return createEmptySseInspectionResult();
  }
  const remainder = state.buffer;
  state.buffer = "";
  return inspectSseBlocks([remainder], config);
}

function createResponsesCodexSseState() {
  return {
    decoder: new TextDecoder("utf8"),
    buffer: "",
    saw_response_completed: false,
    saw_terminal_failure: false,
    response_id: null,
    usage: null,
  };
}

function normalizeResponsesFailedPayloadForCodex(parsed, eventName = "", fallbackResponseId = null) {
  const eventType = firstNonEmptyString(parsed?.type, eventName);
  if (eventType !== "error" && eventType !== "response.failed") {
    return null;
  }
  const normalized = cloneJsonLike(parsed) || {};
  normalized.type = "response.failed";
  if (!normalized.response || typeof normalized.response !== "object" || Array.isArray(normalized.response)) {
    normalized.response = {};
  }
  if (!firstNonEmptyString(normalized.response.status)) {
    normalized.response.status = "failed";
  }
  const responseId = firstNonEmptyString(
    normalized.response.id,
    normalized.id,
    fallbackResponseId,
  );
  if (responseId && !firstNonEmptyString(normalized.response.id)) {
    normalized.response.id = responseId;
  }
  if (!normalized.response.error || typeof normalized.response.error !== "object" || Array.isArray(normalized.response.error)) {
    if (normalized.error && typeof normalized.error === "object" && !Array.isArray(normalized.error)) {
      normalized.response.error = cloneJsonLike(normalized.error);
    } else {
      const fallbackError = {};
      const message = firstNonEmptyString(normalized.message, normalized.error_message);
      const code = firstNonEmptyString(normalized.code, normalized.error_code);
      const errorType = firstNonEmptyString(normalized.error_type, normalized.type);
      if (message) {
        fallbackError.message = message;
      }
      if (code) {
        fallbackError.code = code;
      }
      if (errorType) {
        fallbackError.type = errorType;
      }
      if (Object.keys(fallbackError).length > 0) {
        normalized.response.error = fallbackError;
      }
    }
  }
  for (const key of ["usage", "output", "incomplete_details", "metadata"]) {
    if (normalized.response[key] === undefined && normalized[key] !== undefined) {
      normalized.response[key] = cloneJsonLike(normalized[key]);
    }
  }
  return normalized;
}

function normalizeResponsesLifecyclePayloadForCodex(parsed, eventName = "", fallbackResponseId = null) {
  const eventType = firstNonEmptyString(parsed?.type, eventName);
  if (
    eventType !== "response.created" &&
    eventType !== "response.in_progress" &&
    eventType !== "response.completed" &&
    eventType !== "response.done"
  ) {
    return null;
  }
  const normalizedType = eventType === "response.done" ? "response.completed" : eventType;
  const normalized = {
    type: normalizedType,
    response: {},
  };
  const responseId = firstNonEmptyString(
    parsed?.response?.id,
    parsed?.id,
    fallbackResponseId,
  );
  if (responseId) {
    normalized.response.id = responseId;
  }
  const status = firstNonEmptyString(parsed?.response?.status);
  if (status) {
    normalized.response.status = status;
  }
  const headers = normalizeResponsesHeaderSubset(parsed?.response?.headers, parsed?.headers);
  if (headers) {
    normalized.response.headers = headers;
  }
  if (normalizedType === "response.completed") {
    const usage = cloneJsonLike(parsed?.response?.usage ?? parsed?.usage);
    if (usage !== undefined) {
      normalized.response.usage = usage;
    }
    if (parsed?.response?.end_turn !== undefined) {
      normalized.response.end_turn = parsed.response.end_turn;
    } else if (parsed?.end_turn !== undefined) {
      normalized.response.end_turn = parsed.end_turn;
    }
  }
  return normalized;
}

function normalizeResponsesCompletedPayloadForCodex(parsed, eventName = "", fallbackResponseId = null) {
  const eventType = firstNonEmptyString(parsed?.type, eventName);
  if (eventType !== "response.done" && eventType !== "response.completed") {
    return null;
  }
  return normalizeResponsesLifecyclePayloadForCodex(parsed, eventName, fallbackResponseId);
}

function processResponsesSseBlockForCodex(state, blockText, fallbackResponseId = null) {
  const lines = `${blockText || ""}`
    .split(/\r?\n/)
    .map((line) => line.trimEnd());
  const eventName = lines
    .filter((line) => line.startsWith("event:"))
    .map((line) => line.replace(/^event:\s?/, "").trim())
    .find(Boolean) || "";
  const dataLines = lines
    .filter((line) => line.startsWith("data:"))
    .map((line) => line.replace(/^data:\s?/, ""));

  if (dataLines.length === 0) {
    return Buffer.from(`${lines.join("\n")}\n\n`);
  }

  const payloadText = dataLines.join("\n");
  if (payloadText === "[DONE]") {
    return buildSseBlock(eventName, payloadText);
  }

  let parsed = null;
  try {
    parsed = JSON.parse(payloadText);
  } catch {
    return Buffer.from(`${lines.join("\n")}\n\n`);
  }

  state.usage = mergeUsageSnapshots(state.usage, normalizeUsageSnapshot(parsed));
  state.response_id = state.response_id
    || extractStreamingResponseId(parsed)
    || extractNonStreamingResponseId(parsed)
    || firstNonEmptyString(parsed?.response?.id, fallbackResponseId);

  let rewritten = normalizeResponsesLifecyclePayloadForCodex(
    parsed,
    eventName,
    state.response_id || fallbackResponseId,
  );
  if (!rewritten) {
    rewritten = normalizeResponsesCompletedPayloadForCodex(parsed, eventName, state.response_id || fallbackResponseId);
  }
  if (!rewritten) {
    rewritten = normalizeResponsesFailedPayloadForCodex(parsed, eventName, state.response_id || fallbackResponseId);
  }
  const outputPayload = rewritten || parsed;
  const outputEventName = firstNonEmptyString(outputPayload?.type, eventName);
  state.response_id = state.response_id
    || extractStreamingResponseId(outputPayload)
    || extractNonStreamingResponseId(outputPayload)
    || firstNonEmptyString(outputPayload?.response?.id, fallbackResponseId);
  state.usage = mergeUsageSnapshots(state.usage, normalizeUsageSnapshot(outputPayload));

  if (outputEventName === "response.completed") {
    state.saw_response_completed = true;
  }
  if (outputEventName === "response.failed" || outputEventName === "response.incomplete") {
    state.saw_terminal_failure = true;
  }

  if (!rewritten) {
    return Buffer.from(`${lines.join("\n")}\n\n`);
  }
  return buildSseBlock(outputEventName, JSON.stringify(outputPayload));
}

function drainResponsesSseForCodex(state, chunk, fallbackResponseId = null) {
  const decoded = state.decoder.decode(chunk, { stream: true });
  state.buffer += decoded;
  const blocks = state.buffer.split(/\r?\n\r?\n/);
  state.buffer = blocks.pop() ?? "";
  return blocks
    .filter((block) => block.length > 0)
    .map((block) => processResponsesSseBlockForCodex(state, block, fallbackResponseId))
    .filter((chunkBuffer) => chunkBuffer && chunkBuffer.length > 0);
}

function flushResponsesSseForCodex(state, fallbackResponseId = null, fallbackUsage = null) {
  const flushed = state.decoder.decode();
  if (flushed) {
    state.buffer += flushed;
  }
  const outputs = [];
  if (state.buffer.trim()) {
    outputs.push(processResponsesSseBlockForCodex(state, state.buffer, fallbackResponseId));
  }
  state.buffer = "";

  if (!state.saw_response_completed && !state.saw_terminal_failure) {
    const responseId = firstNonEmptyString(state.response_id, fallbackResponseId);
    if (responseId) {
      const usage = denormalizeUsageSnapshotToResponsesUsage(mergeUsageSnapshots(state.usage, fallbackUsage));
      const payload = {
        type: "response.completed",
        response: {
          id: responseId,
        },
      };
      if (usage) {
        payload.response.usage = usage;
      }
      outputs.push(buildSseBlock("response.completed", JSON.stringify(payload)));
      state.saw_response_completed = true;
    }
  }
  return outputs.filter((chunkBuffer) => chunkBuffer && chunkBuffer.length > 0);
}

function normalizeIntegerList(values, fallback = []) {
  const source = values === undefined || values === null ? fallback : values;
  const normalized = flattenValues(source)
    .flatMap((value) => {
      if (typeof value === "string") {
        return value.split(/[\s,]+/).filter(Boolean);
      }
      return [value];
    })
    .map((value) => Number.parseInt(`${value}`, 10))
    .filter((value) => Number.isInteger(value));

  return [...new Set(normalized)];
}

function normalizeStringList(values, fallback = []) {
  const source = values === undefined || values === null ? fallback : values;
  const normalized = flattenValues(source)
    .flatMap((value) => `${value ?? ""}`.split(/[\s,]+/))
    .map((value) => value.trim())
    .filter(Boolean);

  return [...new Set(normalized)];
}

function normalizePhraseList(values, fallback = []) {
  const source = values === undefined || values === null ? fallback : values;
  const normalized = flattenValues(source)
    .flatMap((value) => {
      if (typeof value === "string") {
        return expandEscapedLineBreaks(value).split(/\r?\n/);
      }
      return [value];
    })
    .map((value) => `${value ?? ""}`.trim())
    .filter(Boolean);

  return [...new Set(normalized)];
}

function normalizeReasoningMatchMode(value) {
  const mode = `${value || DEFAULT_CONFIG.reasoning_match_mode}`.trim().toLowerCase();
  if (["formula_518n_minus_2", "manual"].includes(mode)) {
    return mode;
  }
  return DEFAULT_CONFIG.reasoning_match_mode;
}

function normalizeReasoningEquals(values, fallback = DEFAULT_CONFIG.reasoning_equals) {
  const normalized = normalizeIntegerList(values, fallback);
  return normalized.length > 0 ? normalized : [...fallback];
}

function normalizePositiveInteger(value, fallback) {
  const parsed = Number.parseInt(`${value ?? ""}`, 10);
  if (Number.isInteger(parsed) && parsed > 0) {
    return parsed;
  }
  return fallback;
}

function normalizeNonNegativeInteger(value, fallback) {
  const parsed = Number.parseInt(`${value ?? ""}`, 10);
  if (Number.isInteger(parsed) && parsed >= 0) {
    return parsed;
  }
  return fallback;
}

function sleep(ms) {
  if (!Number.isFinite(ms) || ms <= 0) {
    return Promise.resolve();
  }
  return new Promise((resolve) => setTimeout(resolve, ms));
}

function parseModelRemapMap(value) {
  const map = {};
  for (const rawEntry of `${value || ""}`.split(/\r?\n|[;,]/)) {
    const entry = rawEntry.trim();
    if (!entry) {
      continue;
    }
    const separatorIndex = entry.indexOf("=");
    if (separatorIndex <= 0) {
      continue;
    }
    const from = entry.slice(0, separatorIndex).trim();
    const to = entry.slice(separatorIndex + 1).trim();
    if (!from || !to) {
      continue;
    }
    map[from] = to;
  }
  return map;
}

function canHotSwapProfile(currentConfig, nextConfig) {
  return (
    `${currentConfig?.listen_host || ""}` === `${nextConfig?.listen_host || ""}` &&
    Number.parseInt(`${currentConfig?.listen_port || ""}`, 10) === Number.parseInt(`${nextConfig?.listen_port || ""}`, 10)
  );
}

function parseEnvText(content) {
  const values = {};
  for (const rawLine of `${content || ""}`.split(/\r?\n/)) {
    const line = rawLine.trim();
    if (!line || line.startsWith("#")) {
      continue;
    }
    const separatorIndex = line.indexOf("=");
    if (separatorIndex <= 0) {
      continue;
    }
    const key = line.slice(0, separatorIndex).trim();
    let value = line.slice(separatorIndex + 1).trim();
    if (
      (value.startsWith('"') && value.endsWith('"')) ||
      (value.startsWith("'") && value.endsWith("'"))
    ) {
      value = value.slice(1, -1);
    }
    values[key] = value;
  }
  return values;
}

function isSecretLikeKey(key) {
  return /TOKEN|SECRET|PASSWORD|API_KEY|AUTH|BEARER|KEY/i.test(`${key || ""}`);
}

function redactProfileValue(key, value) {
  if (!value) {
    return "";
  }
  if (isSecretLikeKey(key) || /^sk-[A-Za-z0-9_-]+/.test(value)) {
    return "[configured]";
  }
  return value;
}

function getProfileNameFromFile(fileName) {
  if (!fileName.endsWith(".env")) {
    return null;
  }
  const profileName = fileName.slice(0, -4);
  return /^[A-Za-z0-9_.-]+$/.test(profileName) ? profileName : null;
}

function validateProfileName(profileName) {
  if (!/^[A-Za-z0-9_.-]+$/.test(profileName)) {
    throw new Error("profile 名称只能包含字母、数字、下划线、点和短横线");
  }
}

function buildBlockedBody(pathname, reasoning, statusCode) {
  return JSON.stringify({
    error: {
      message: `codex retry gateway blocked suspicious reasoning response on ${pathname}`,
      type: "codex_retry_gateway",
      code: "reasoning_guard_triggered",
      reasoning_tokens: reasoning,
      status_code: statusCode,
    },
  });
}

function buildRetryableUpstreamErrorBody(pathname, upstreamStatusCode, upstreamMessage, statusCode) {
  return JSON.stringify({
    error: {
      message: `codex retry gateway converted retryable upstream error on ${pathname}`,
      type: "codex_retry_gateway",
      code: "upstream_error_retry_triggered",
      upstream_status_code: upstreamStatusCode,
      upstream_error_message: upstreamMessage,
      status_code: statusCode,
    },
  });
}

function buildGatewayErrorBody(message) {
  return JSON.stringify({
    error: {
      message,
      type: "codex_retry_gateway_error",
      code: "gateway_error",
    },
  });
}

function createMonitor() {
  return {
    started_at: new Date().toISOString(),
    persistent_since: null,
    next_log_seq: 1,
    next_request_seq: 1,
    log_entries: [],
    request_entries: [],
    total_proxy_request_count: 0,
    inspected_response_count: 0,
    matched_response_count: 0,
    token_totals: {
      input_tokens: 0,
      output_tokens: 0,
      total_tokens: 0,
      reasoning_tokens: 0,
      cached_tokens: 0,
    },
    observed_reasoning_counts: {},
  };
}

function buildLogEntry(seq, at, message) {
  return {
    seq,
    at,
    message,
  };
}

function parseLogLine(line, seq) {
  const match = `${line || ""}`.match(/^(\S+)\s([\s\S]*)$/);
  if (!match) {
    return buildLogEntry(seq, null, line);
  }
  return buildLogEntry(seq, match[1], match[2]);
}

function parseJsonLine(line) {
  if (!line.trim()) {
    return null;
  }
  try {
    return JSON.parse(line);
  } catch {
    return null;
  }
}

async function readJsonlFile(filePath) {
  const text = await readOptionalText(filePath);
  if (!text) {
    return [];
  }
  return text
    .split(/\r?\n/)
    .map(parseJsonLine)
    .filter(Boolean);
}

async function appendJsonl(filePath, value) {
  await mkdir(path.dirname(filePath), { recursive: true });
  await fs.promises.appendFile(filePath, `${JSON.stringify(value)}\n`, "utf8");
}

function openRequestsDatabase(dbPath) {
  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
  const db = new DatabaseSync(dbPath);
  db.exec(`
    PRAGMA journal_mode = WAL;
    CREATE TABLE IF NOT EXISTS requests (
      seq INTEGER PRIMARY KEY,
      request_id TEXT,
      response_id TEXT,
      thread_id TEXT,
      started_at TEXT,
      finished_at TEXT,
      duration_ms INTEGER,
      profile_name TEXT,
      method TEXT,
      path TEXT,
      model TEXT,
      requested_model TEXT,
      forwarded_model TEXT,
      reasoning_effort TEXT,
      reasoning_summary TEXT,
      request_stream INTEGER,
      response_stream INTEGER,
      inspected INTEGER,
      matched INTEGER,
      status_code INTEGER,
      upstream_status_code INTEGER,
      reasoning_tokens INTEGER,
      input_tokens INTEGER,
      output_tokens INTEGER,
      total_tokens INTEGER,
      cached_tokens INTEGER,
      error TEXT,
      upstream_origin TEXT,
      upstream_path TEXT,
      upstream_auth_mode TEXT,
      upstream_auth_source TEXT,
      payload_json TEXT NOT NULL
    );
    CREATE INDEX IF NOT EXISTS idx_requests_started_at ON requests(started_at DESC);
    CREATE INDEX IF NOT EXISTS idx_requests_profile_name ON requests(profile_name);
    CREATE INDEX IF NOT EXISTS idx_requests_status_code ON requests(status_code);
    CREATE INDEX IF NOT EXISTS idx_requests_matched ON requests(matched);
    CREATE INDEX IF NOT EXISTS idx_requests_response_stream ON requests(response_stream);
  `);
  const requestColumns = db.prepare("PRAGMA table_info(requests)").all();
  const requestColumnNames = new Set(requestColumns.map((column) => column.name));
  if (!requestColumnNames.has("request_id")) {
    db.exec("ALTER TABLE requests ADD COLUMN request_id TEXT");
  }
  if (!requestColumnNames.has("response_id")) {
    db.exec("ALTER TABLE requests ADD COLUMN response_id TEXT");
  }
  if (!requestColumnNames.has("thread_id")) {
    db.exec("ALTER TABLE requests ADD COLUMN thread_id TEXT");
  }
  if (!requestColumnNames.has("reasoning_effort")) {
    db.exec("ALTER TABLE requests ADD COLUMN reasoning_effort TEXT");
  }
  if (!requestColumnNames.has("reasoning_summary")) {
    db.exec("ALTER TABLE requests ADD COLUMN reasoning_summary TEXT");
  }
  db.exec("CREATE INDEX IF NOT EXISTS idx_requests_request_id ON requests(request_id)");
  db.exec("CREATE INDEX IF NOT EXISTS idx_requests_response_id ON requests(response_id)");
  db.exec("CREATE INDEX IF NOT EXISTS idx_requests_thread_id ON requests(thread_id)");
  db.exec("CREATE INDEX IF NOT EXISTS idx_requests_reasoning_effort ON requests(reasoning_effort)");
  return db;
}

function boolToInt(value) {
  return value ? 1 : 0;
}

function usageField(entry, key) {
  const value = entry?.usage?.[key];
  return Number.isInteger(value) ? value : null;
}

function buildPersistedRequestPayload(entry) {
  return Object.fromEntries(
    Object.entries(entry || {}).filter(([key]) => !key.startsWith("_")),
  );
}

function computeRequestId(pathname, rawBody) {
  const hash = createHash("sha256");
  hash.update(normalizePath(pathname));
  hash.update("\n");
  hash.update(Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(rawBody || ""));
  return `req_${hash.digest("hex").slice(0, 16)}`;
}

function requestRowFromEntry(entry) {
  const payload = buildPersistedRequestPayload(entry);
  return {
    seq: entry.seq,
    request_id: entry.request_id || null,
    response_id: entry.response_id || null,
    thread_id: entry.thread_id || null,
    started_at: entry.started_at || null,
    finished_at: entry.finished_at || null,
    duration_ms: Number.isInteger(entry.duration_ms) ? entry.duration_ms : null,
    profile_name: entry.profile_name || null,
    method: entry.method || null,
    path: entry.path || null,
    model: entry.model || null,
    requested_model: entry.requested_model || null,
    forwarded_model: entry.forwarded_model || null,
    reasoning_effort: entry.reasoning_effort || null,
    reasoning_summary: entry.reasoning_summary || null,
    request_stream: boolToInt(Boolean(entry.request_stream)),
    response_stream: boolToInt(Boolean(entry.response_stream)),
    inspected: boolToInt(Boolean(entry.inspected)),
    matched: boolToInt(Boolean(entry.matched)),
    status_code: Number.isInteger(entry.status_code) ? entry.status_code : null,
    upstream_status_code: Number.isInteger(entry.upstream_status_code) ? entry.upstream_status_code : null,
    reasoning_tokens: Number.isInteger(entry.reasoning_tokens) ? entry.reasoning_tokens : usageField(entry, "reasoning_tokens"),
    input_tokens: usageField(entry, "input_tokens"),
    output_tokens: usageField(entry, "output_tokens"),
    total_tokens: usageField(entry, "total_tokens"),
    cached_tokens: usageField(entry, "cached_tokens"),
    error: entry.error || null,
    upstream_origin: entry.upstream?.origin || null,
    upstream_path: entry.upstream?.path || null,
    upstream_auth_mode: entry.upstream?.auth_mode || null,
    upstream_auth_source: entry.upstream?.auth_source || null,
    payload_json: JSON.stringify(payload),
  };
}

function insertRequestRow(db, row) {
  db.prepare(`
    INSERT OR REPLACE INTO requests (
      seq, request_id, response_id, thread_id, started_at, finished_at, duration_ms, profile_name, method, path, model,
      requested_model, forwarded_model, reasoning_effort, reasoning_summary, request_stream, response_stream, inspected, matched,
      status_code, upstream_status_code, reasoning_tokens, input_tokens, output_tokens,
      total_tokens, cached_tokens, error, upstream_origin, upstream_path,
      upstream_auth_mode, upstream_auth_source, payload_json
    ) VALUES (
      @seq, @request_id, @response_id, @thread_id, @started_at, @finished_at, @duration_ms, @profile_name, @method, @path, @model,
      @requested_model, @forwarded_model, @reasoning_effort, @reasoning_summary, @request_stream, @response_stream, @inspected, @matched,
      @status_code, @upstream_status_code, @reasoning_tokens, @input_tokens, @output_tokens,
      @total_tokens, @cached_tokens, @error, @upstream_origin, @upstream_path,
      @upstream_auth_mode, @upstream_auth_source, @payload_json
    )
  `).run(row);
}

async function importRequestsJsonlToDb(db, filePath) {
  const rows = await readJsonlFile(filePath);
  if (rows.length === 0) {
    return 0;
  }
  const countRow = db.prepare("SELECT COUNT(*) AS count FROM requests").get();
  if ((countRow?.count || 0) >= rows.length) {
    return 0;
  }
  db.exec("BEGIN");
  try {
    for (const entry of rows) {
      if (!Number.isInteger(entry?.seq)) {
        continue;
      }
      insertRequestRow(db, requestRowFromEntry(entry));
    }
    db.exec("COMMIT");
  } catch (error) {
    try {
      db.exec("ROLLBACK");
    } catch {
      // Ignore rollback failures so the original insert error is preserved.
    }
    throw error;
  }
  return rows.length;
}

function parseRequestRowPayload(row) {
  if (!row?.payload_json) {
    return null;
  }
  try {
    return JSON.parse(row.payload_json);
  } catch {
    return null;
  }
}

function buildRequestQueryFilters({ query, filter }) {
  const clauses = [];
  const params = {};

  const trimmedQuery = `${query || ""}`.trim().toLowerCase();
  if (trimmedQuery) {
    clauses.push(`
      (
        lower(coalesce(profile_name, '')) LIKE @query OR
        lower(coalesce(method, '')) LIKE @query OR
        lower(coalesce(path, '')) LIKE @query OR
        lower(coalesce(request_id, '')) LIKE @query OR
        lower(coalesce(response_id, '')) LIKE @query OR
        lower(coalesce(thread_id, '')) LIKE @query OR
        lower(coalesce(model, '')) LIKE @query OR
        lower(coalesce(requested_model, '')) LIKE @query OR
        lower(coalesce(forwarded_model, '')) LIKE @query OR
        lower(coalesce(reasoning_effort, '')) LIKE @query OR
        lower(coalesce(reasoning_summary, '')) LIKE @query OR
        lower(coalesce(error, '')) LIKE @query OR
        lower(coalesce(upstream_origin, '')) LIKE @query OR
        lower(coalesce(upstream_path, '')) LIKE @query OR
        CAST(coalesce(status_code, '') AS TEXT) LIKE @query OR
        CAST(coalesce(upstream_status_code, '') AS TEXT) LIKE @query OR
        CAST(coalesce(input_tokens, '') AS TEXT) LIKE @query OR
        CAST(coalesce(output_tokens, '') AS TEXT) LIKE @query OR
        CAST(coalesce(total_tokens, '') AS TEXT) LIKE @query OR
        CAST(coalesce(cached_tokens, '') AS TEXT) LIKE @query OR
        CAST(coalesce(reasoning_tokens, '') AS TEXT) LIKE @query
      )
    `);
    params.query = `%${trimmedQuery}%`;
  }

  if (filter === "matched") {
    clauses.push("matched = 1");
  } else if (filter === "stream") {
    clauses.push("response_stream = 1");
  } else if (filter === "error") {
    clauses.push("(error IS NOT NULL AND error != '')");
  }

  return {
    whereSql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
    params,
  };
}

async function hydrateMonitorFromDisk(monitor, paths, requestHistoryLimit, requestsDb = null) {
  monitor.request_entries = [];

  if (requestsDb) {
    const totalsRow = requestsDb.prepare(`
      SELECT
        COUNT(*) AS total_proxy_request_count,
        COALESCE(SUM(CASE WHEN inspected = 1 THEN 1 ELSE 0 END), 0) AS inspected_response_count,
        COALESCE(SUM(CASE WHEN matched = 1 THEN 1 ELSE 0 END), 0) AS matched_response_count,
        COALESCE(SUM(COALESCE(input_tokens, 0)), 0) AS input_tokens,
        COALESCE(SUM(COALESCE(output_tokens, 0)), 0) AS output_tokens,
        COALESCE(SUM(COALESCE(total_tokens, 0)), 0) AS total_tokens,
        COALESCE(SUM(COALESCE(reasoning_tokens, 0)), 0) AS reasoning_tokens,
        COALESCE(SUM(COALESCE(cached_tokens, 0)), 0) AS cached_tokens,
        MIN(NULLIF(started_at, '')) AS persistent_since,
        MAX(seq) AS max_seq
      FROM requests
    `).get();

    monitor.total_proxy_request_count = totalsRow?.total_proxy_request_count || 0;
    monitor.inspected_response_count = totalsRow?.inspected_response_count || 0;
    monitor.matched_response_count = totalsRow?.matched_response_count || 0;
    monitor.token_totals = {
      input_tokens: totalsRow?.input_tokens || 0,
      output_tokens: totalsRow?.output_tokens || 0,
      total_tokens: totalsRow?.total_tokens || 0,
      reasoning_tokens: totalsRow?.reasoning_tokens || 0,
      cached_tokens: totalsRow?.cached_tokens || 0,
    };
    monitor.persistent_since = totalsRow?.persistent_since || null;
    monitor.next_request_seq = Number.isInteger(totalsRow?.max_seq) ? totalsRow.max_seq + 1 : 1;
    monitor.observed_reasoning_counts = {};

    const reasoningRows = requestsDb.prepare(`
      SELECT reasoning_tokens, COUNT(*) AS count
      FROM requests
      WHERE reasoning_tokens IS NOT NULL
      GROUP BY reasoning_tokens
    `).all();
    for (const row of reasoningRows) {
      if (!Number.isInteger(row?.reasoning_tokens)) {
        continue;
      }
      monitor.observed_reasoning_counts[`${row.reasoning_tokens}`] = row.count || 0;
    }

    const persistedRows = requestsDb.prepare("SELECT payload_json FROM requests").all();
    for (const row of persistedRows) {
      const entry = parseRequestRowPayload(row);
      if (!entry) {
        continue;
      }
      applyPersistedRetryExtras(monitor, entry);
    }
    return;
  }

  const requestEntries = await readJsonlFile(paths.requestsPath);
  monitor.next_request_seq = requestEntries.reduce((maxSeq, entry) => {
    return Math.max(maxSeq, Number.isInteger(entry.seq) ? entry.seq + 1 : maxSeq);
  }, 1);
  for (const entry of requestEntries) {
    monitor.total_proxy_request_count += 1;
    if (entry.inspected) {
      recordInspectedResponse(monitor, entry.reasoning_tokens ?? entry.usage?.reasoning_tokens ?? null, Boolean(entry.matched));
    }
    applyPersistedRetryExtras(monitor, entry);
    addTokenTotals(monitor, entry.usage);
  }
  const firstStartedAt = requestEntries
    .map((entry) => `${entry?.started_at || ""}`.trim())
    .filter(Boolean)
    .sort()[0];
  monitor.persistent_since = firstStartedAt || null;
}

function createMonitorRecorder(monitor) {
  return (message) => {
    const entry = {
      seq: monitor.next_log_seq,
      at: new Date().toISOString(),
      message,
    };
    monitor.next_log_seq += 1;
    monitor.log_entries.push(entry);
    return entry;
  };
}

function createLogger(logPath, recordEntry) {
  if (!logPath) {
    return (message) => {
      const entry = recordEntry ? recordEntry(message) : { at: new Date().toISOString(), message };
      process.stdout.write(`${entry.at} ${entry.message}\n`);
    };
  }

  const stream = fs.createWriteStream(logPath, { flags: "a" });
  return (message) => {
    const entry = recordEntry ? recordEntry(message) : { at: new Date().toISOString(), message };
    const line = `${entry.at} ${entry.message}\n`;
    stream.write(line);
    process.stdout.write(line);
  };
}

function incrementReasoningCount(counter, reasoning) {
  if (!Number.isInteger(reasoning)) {
    return;
  }
  const key = `${reasoning}`;
  counter[key] = (counter[key] || 0) + 1;
}

function recordInspectedResponse(monitor, reasoning, matched) {
  monitor.inspected_response_count += 1;
  incrementReasoningCount(monitor.observed_reasoning_counts, reasoning);
  if (matched) {
    monitor.matched_response_count += 1;
  }
}

function applyPersistedRetryExtras(monitor, entry) {
  const extraInspectedCount = Number.isInteger(entry?.reasoning_retry_extra_inspected_count)
    ? entry.reasoning_retry_extra_inspected_count
    : 0;
  const extraMatchedCount = Number.isInteger(entry?.reasoning_retry_extra_matched_count)
    ? entry.reasoning_retry_extra_matched_count
    : 0;
  monitor.inspected_response_count += extraInspectedCount;
  monitor.matched_response_count += extraMatchedCount;

  const extraReasoningCounts = entry?.reasoning_retry_extra_reasoning_counts;
  if (extraReasoningCounts && typeof extraReasoningCounts === "object") {
    for (const [reasoningKey, count] of Object.entries(extraReasoningCounts)) {
      const parsedReasoning = Number.parseInt(reasoningKey, 10);
      if (!Number.isInteger(parsedReasoning) || !Number.isInteger(count) || count <= 0) {
        continue;
      }
      monitor.observed_reasoning_counts[`${parsedReasoning}`] = (
        monitor.observed_reasoning_counts[`${parsedReasoning}`] || 0
      ) + count;
    }
  }

  addTokenTotals(monitor, entry?.reasoning_retry_extra_usage || null);
}

function addTokenTotals(monitor, usage) {
  if (!usage) {
    return;
  }
  for (const key of ["input_tokens", "output_tokens", "total_tokens", "reasoning_tokens", "cached_tokens"]) {
    const value = usage[key];
    if (Number.isInteger(value)) {
      monitor.token_totals[key] += value;
    }
  }
}

function upsertRequestEntry(runtime, entry, { persistJsonl = false, includeUsage = false } = {}) {
  if (includeUsage) {
    addTokenTotals(runtime.monitor, entry.usage);
    addTokenTotals(runtime.monitor, entry.reasoning_retry_extra_usage || null);
  }
  if (runtime.requestsDb) {
    insertRequestRow(runtime.requestsDb, requestRowFromEntry(entry));
  }
  if (persistJsonl) {
    appendJsonl(runtime.paths.requestsPath, buildPersistedRequestPayload(entry)).catch((error) => {
      runtime.logger?.(`[requests] failed to persist request seq=${entry.seq}: ${error?.message || error}`);
    });
  }
}

function recordRequestEntry(runtime, entry, limit = DEFAULT_CONFIG.request_history_limit) {
  upsertRequestEntry(runtime, entry, {
    persistJsonl: true,
    includeUsage: true,
  });
}

function markAndPersistFirstResponse(runtime, entry, at = new Date()) {
  if (!markRequestFirstResponse(entry, at)) {
    return false;
  }
  upsertRequestEntry(runtime, entry);
  return true;
}

function markRequestEntryFirstResponse(runtime, entry, { persistEntry = true, at = new Date() } = {}) {
  if (!markRequestFirstResponse(entry, at)) {
    return false;
  }
  if (persistEntry) {
    upsertRequestEntry(runtime, entry);
  }
  return true;
}

function summarizeProfileAuthSource(env, options = {}) {
  const prefix = options.prefix || "CODEX_RETRY_GATEWAY_UPSTREAM";
  const defaultMode = options.defaultMode || "passthrough";
  const mode = env[`${prefix}_AUTH_MODE`] || defaultMode;
  if (mode === "auth_json") {
    return env[`${prefix}_AUTH_JSON_PATH`] ? "auth.json path configured" : "~/.codex/auth.json";
  }
  if (mode === "manual_bearer") {
    const secretPath = env[`${prefix}_AUTH_FILE`] || "";
    if (!secretPath) {
      return "system secret file missing";
    }
    return fs.existsSync(secretPath) ? "system secret file configured" : "system secret file missing";
  }
  if (mode === "fixed_bearer") {
    if (env[`${prefix}_AUTH_FILE`]) {
      return "token file configured";
    }
    if (env[`${prefix}_AUTH_ENV`]) {
      return `env:${env[`${prefix}_AUTH_ENV`]}`;
    }
  }
  return "passthrough";
}

function summarizeImageProfileAuthSource(env) {
  return summarizeProfileAuthSource(env, {
    prefix: "CODEX_RETRY_GATEWAY_IMAGE",
    defaultMode: DEFAULT_CONFIG.image_auth_mode,
  });
}

function buildProfileFormModel(env) {
  const manualSecretFile = env.CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_FILE || "";
  return {
    listen_host: env.CODEX_RETRY_GATEWAY_LISTEN_HOST || "",
    listen_port: env.CODEX_RETRY_GATEWAY_LISTEN_PORT || "",
    upstream_base_url: env.CODEX_RETRY_GATEWAY_UPSTREAM_BASE_URL || "",
    auth_mode: env.CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_MODE || "passthrough",
    auth_env: env.CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_ENV || "",
    auth_file: env.CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_MODE === "manual_bearer"
      ? ""
      : env.CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_FILE || "",
    manual_secret_file: env.CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_MODE === "manual_bearer"
      ? manualSecretFile
      : "",
    manual_secret_configured: env.CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_MODE === "manual_bearer"
      && Boolean(manualSecretFile)
      && fs.existsSync(manualSecretFile),
    auth_json_path: env.CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_JSON_PATH || "",
    auth_json_key: env.CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_JSON_KEY || "",
    request_history_limit: env.CODEX_RETRY_GATEWAY_REQUEST_HISTORY_LIMIT || `${DEFAULT_CONFIG.request_history_limit}`,
    model_remap: env.CODEX_RETRY_GATEWAY_MODEL_REMAP || "",
    reasoning_match_mode: normalizeReasoningMatchMode(env.CODEX_RETRY_GATEWAY_REASONING_MATCH_MODE),
    reasoning_equals: normalizeReasoningEquals(
      env.CODEX_RETRY_GATEWAY_REASONING_EQUALS || DEFAULT_CONFIG.reasoning_equals,
      DEFAULT_CONFIG.reasoning_equals,
    ).join(","),
    retryable_status_codes: env.CODEX_RETRY_GATEWAY_RETRYABLE_STATUS_CODES || "",
    retryable_error_messages: normalizePhraseList(
      env.CODEX_RETRY_GATEWAY_RETRYABLE_ERROR_MESSAGES || DEFAULT_CONFIG.retryable_error_messages,
      DEFAULT_CONFIG.retryable_error_messages,
    ),
    upstream_fetch_retry_attempts:
      env.CODEX_RETRY_GATEWAY_UPSTREAM_FETCH_RETRY_ATTEMPTS || `${DEFAULT_CONFIG.upstream_fetch_retry_attempts}`,
    upstream_fetch_retry_backoff_ms:
      env.CODEX_RETRY_GATEWAY_UPSTREAM_FETCH_RETRY_BACKOFF_MS || `${DEFAULT_CONFIG.upstream_fetch_retry_backoff_ms}`,
    endpoints: normalizeStringList(env.CODEX_RETRY_GATEWAY_ENDPOINTS || DEFAULT_CONFIG.endpoints, DEFAULT_CONFIG.endpoints),
  };
}

function buildImageProfileFormModel(env) {
  const manualSecretFile = env.CODEX_RETRY_GATEWAY_IMAGE_AUTH_FILE || "";
  return {
    base_url: env.CODEX_RETRY_GATEWAY_IMAGE_BASE_URL || "",
    auth_mode: env.CODEX_RETRY_GATEWAY_IMAGE_AUTH_MODE || DEFAULT_CONFIG.image_auth_mode,
    auth_env: env.CODEX_RETRY_GATEWAY_IMAGE_AUTH_ENV || DEFAULT_CONFIG.image_auth_env,
    auth_file: env.CODEX_RETRY_GATEWAY_IMAGE_AUTH_MODE === "manual_bearer"
      ? ""
      : manualSecretFile,
    manual_secret_file: env.CODEX_RETRY_GATEWAY_IMAGE_AUTH_MODE === "manual_bearer"
      ? manualSecretFile
      : "",
    manual_secret_configured: env.CODEX_RETRY_GATEWAY_IMAGE_AUTH_MODE === "manual_bearer"
      && Boolean(manualSecretFile)
      && fs.existsSync(manualSecretFile),
    auth_json_path: env.CODEX_RETRY_GATEWAY_IMAGE_AUTH_JSON_PATH || "",
    auth_json_key: env.CODEX_RETRY_GATEWAY_IMAGE_AUTH_JSON_KEY || DEFAULT_CONFIG.image_auth_json_key,
  };
}

function imageConfigFromConfig(config) {
  return {
    image_profile_name: `${config?.image_profile_name || ""}`.trim(),
    image_base_url: `${config?.image_base_url || ""}`.trim(),
    image_auth_mode: config?.image_auth_mode || DEFAULT_CONFIG.image_auth_mode,
    image_auth_env: config?.image_auth_env || DEFAULT_CONFIG.image_auth_env,
    image_auth_file: config?.image_auth_file || "",
    image_auth_json_path: config?.image_auth_json_path || "",
    image_auth_json_key: config?.image_auth_json_key || DEFAULT_CONFIG.image_auth_json_key,
  };
}

function buildImageConfigFromProfileEnv(imageProfileName, env) {
  const form = buildImageProfileFormModel(env);
  const baseUrl = `${form.base_url || ""}`.trim();
  if (baseUrl) {
    try {
      new URL(baseUrl);
    } catch {
      throw new Error("图片上游 Base URL 必须是合法 URL");
    }
  }
  return {
    image_profile_name: imageProfileName || "",
    image_base_url: baseUrl,
    image_auth_mode: normalizeAuthMode(form.auth_mode),
    image_auth_env: form.auth_env || DEFAULT_CONFIG.image_auth_env,
    image_auth_file: env.CODEX_RETRY_GATEWAY_IMAGE_AUTH_FILE || "",
    image_auth_json_path: form.auth_json_path || "",
    image_auth_json_key: form.auth_json_key || DEFAULT_CONFIG.image_auth_json_key,
  };
}

function buildConfigFromProfileEnv(profileName, env, imageConfig = {}) {
  const reasoningMatchMode = normalizeReasoningMatchMode(env.CODEX_RETRY_GATEWAY_REASONING_MATCH_MODE);
  const config = {
    ...DEFAULT_CONFIG,
    ...imageConfigFromConfig(imageConfig),
    profile_name: profileName,
    listen_host: env.CODEX_RETRY_GATEWAY_LISTEN_HOST || DEFAULT_CONFIG.listen_host,
    listen_port: env.CODEX_RETRY_GATEWAY_LISTEN_PORT
      ? Number.parseInt(`${env.CODEX_RETRY_GATEWAY_LISTEN_PORT}`, 10)
      : DEFAULT_CONFIG.listen_port,
    upstream_base_url: env.CODEX_RETRY_GATEWAY_UPSTREAM_BASE_URL || "",
    upstream_auth_mode: env.CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_MODE || DEFAULT_CONFIG.upstream_auth_mode,
    upstream_auth_env: env.CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_ENV || DEFAULT_CONFIG.upstream_auth_env,
    upstream_auth_file: env.CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_FILE || "",
    upstream_auth_json_path: env.CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_JSON_PATH || "",
    upstream_auth_json_key: env.CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_JSON_KEY || DEFAULT_CONFIG.upstream_auth_json_key,
    request_body_limit_bytes: env.CODEX_RETRY_GATEWAY_REQUEST_BODY_LIMIT_BYTES
      ? Number.parseInt(`${env.CODEX_RETRY_GATEWAY_REQUEST_BODY_LIMIT_BYTES}`, 10)
      : DEFAULT_CONFIG.request_body_limit_bytes,
    request_history_limit: env.CODEX_RETRY_GATEWAY_REQUEST_HISTORY_LIMIT
      ? Number.parseInt(`${env.CODEX_RETRY_GATEWAY_REQUEST_HISTORY_LIMIT}`, 10)
      : DEFAULT_CONFIG.request_history_limit,
    model_remap: env.CODEX_RETRY_GATEWAY_MODEL_REMAP || "",
    endpoints: normalizeStringList(env.CODEX_RETRY_GATEWAY_ENDPOINTS || DEFAULT_CONFIG.endpoints, DEFAULT_CONFIG.endpoints).map(normalizePath),
    reasoning_match_mode: reasoningMatchMode,
    reasoning_equals: normalizeReasoningEquals(
      env.CODEX_RETRY_GATEWAY_REASONING_EQUALS || DEFAULT_CONFIG.reasoning_equals,
      DEFAULT_CONFIG.reasoning_equals,
    ),
    retryable_status_codes: normalizeIntegerList(
      env.CODEX_RETRY_GATEWAY_RETRYABLE_STATUS_CODES || DEFAULT_CONFIG.retryable_status_codes,
      DEFAULT_CONFIG.retryable_status_codes,
    ),
    retryable_error_messages: normalizePhraseList(
      env.CODEX_RETRY_GATEWAY_RETRYABLE_ERROR_MESSAGES || DEFAULT_CONFIG.retryable_error_messages,
      DEFAULT_CONFIG.retryable_error_messages,
    ),
    management_access_key: normalizeManagementAccessKey(
      env.CODEX_RETRY_GATEWAY_MANAGEMENT_ACCESS_KEY || DEFAULT_CONFIG.management_access_key,
    ),
    upstream_fetch_retry_attempts: env.CODEX_RETRY_GATEWAY_UPSTREAM_FETCH_RETRY_ATTEMPTS
      ? normalizePositiveInteger(
          env.CODEX_RETRY_GATEWAY_UPSTREAM_FETCH_RETRY_ATTEMPTS,
          DEFAULT_CONFIG.upstream_fetch_retry_attempts,
        )
      : DEFAULT_CONFIG.upstream_fetch_retry_attempts,
    upstream_fetch_retry_backoff_ms: env.CODEX_RETRY_GATEWAY_UPSTREAM_FETCH_RETRY_BACKOFF_MS
      ? normalizeNonNegativeInteger(
          env.CODEX_RETRY_GATEWAY_UPSTREAM_FETCH_RETRY_BACKOFF_MS,
          DEFAULT_CONFIG.upstream_fetch_retry_backoff_ms,
        )
      : DEFAULT_CONFIG.upstream_fetch_retry_backoff_ms,
    non_stream_status_code: env.CODEX_RETRY_GATEWAY_NON_STREAM_STATUS_CODE
      ? Number.parseInt(`${env.CODEX_RETRY_GATEWAY_NON_STREAM_STATUS_CODE}`, 10)
      : DEFAULT_CONFIG.non_stream_status_code,
    stream_action: env.CODEX_RETRY_GATEWAY_STREAM_ACTION || DEFAULT_CONFIG.stream_action,
    log_match: env.CODEX_RETRY_GATEWAY_LOG_MATCH === undefined
      ? DEFAULT_CONFIG.log_match
      : ["1", "true", "yes", "on"].includes(`${env.CODEX_RETRY_GATEWAY_LOG_MATCH}`.trim().toLowerCase()),
    health_path: env.CODEX_RETRY_GATEWAY_HEALTH_PATH || DEFAULT_CONFIG.health_path,
  };
  config.model_remap_map = parseModelRemapMap(config.model_remap);
  return config;
}

function assertNoInlineProfileSecret(payload, fields = [
    "auth_env",
    "auth_file",
    "auth_json_path",
    "auth_json_key",
    "upstream_base_url",
  ]) {
  for (const field of fields) {
    const value = `${payload?.[field] || ""}`.trim();
    if (/^sk-[A-Za-z0-9_-]+/.test(value) || /Bearer\s+sk-[A-Za-z0-9_-]+/i.test(value)) {
      throw new Error("profile 不保存明文 sk 密钥；请改用 env/file/auth.json 引用");
    }
  }
}

function defaultManualSecretPath(profileName) {
  const homeDir = process.env.HOME || "";
  return path.join(homeDir, ".codex-retry-gateway", "secrets", `${profileName}.token`);
}

function defaultImageManualSecretPath(profileName) {
  const homeDir = process.env.HOME || "";
  return path.join(homeDir, ".codex-retry-gateway", "secrets", `${profileName}.images.token`);
}

async function writeManualSecret(profileName, secretValue) {
  const text = `${secretValue || ""}`.trim();
  if (!text) {
    return null;
  }

  const secretPath = defaultManualSecretPath(profileName);
  await mkdir(path.dirname(secretPath), { recursive: true, mode: 0o700 });
  await writeFile(secretPath, `${text}\n`, { encoding: "utf8", mode: 0o600 });
  await chmod(path.dirname(secretPath), 0o700).catch(() => {});
  await chmod(secretPath, 0o600).catch(() => {});
  return secretPath;
}

async function writeImageManualSecret(profileName, secretValue) {
  const text = `${secretValue || ""}`.trim();
  if (!text) {
    return null;
  }

  const secretPath = defaultImageManualSecretPath(profileName);
  await mkdir(path.dirname(secretPath), { recursive: true, mode: 0o700 });
  await writeFile(secretPath, `${text}\n`, { encoding: "utf8", mode: 0o600 });
  await chmod(path.dirname(secretPath), 0o700).catch(() => {});
  await chmod(secretPath, 0o600).catch(() => {});
  return secretPath;
}

function serializeEnvValue(value) {
  const text = `${value ?? ""}`;
  if (/^[A-Za-z0-9_./:@?&=,+-]*$/.test(text)) {
    return text;
  }
  return JSON.stringify(text);
}

async function buildProfileEnvText(payload) {
  assertNoInlineProfileSecret(payload);

  const name = `${payload?.name || ""}`.trim();
  validateProfileName(name);

  const listenPort = Number.parseInt(`${payload.listen_port || DEFAULT_CONFIG.listen_port}`, 10);
  if (!Number.isInteger(listenPort) || listenPort < 1 || listenPort > 65535) {
    throw new Error("监听端口必须是 1-65535 的整数");
  }

  const upstreamBaseUrl = `${payload.upstream_base_url || ""}`.trim();
  if (!upstreamBaseUrl) {
    throw new Error("上游 Base URL 不能为空");
  }
  try {
    new URL(upstreamBaseUrl);
  } catch {
    throw new Error("上游 Base URL 必须是合法 URL");
  }

  const authMode = normalizeAuthMode(payload.auth_mode);
  const reasoningMatchMode = normalizeReasoningMatchMode(payload.reasoning_match_mode);
  const reasoningEquals = normalizeReasoningEquals(payload.reasoning_equals, DEFAULT_CONFIG.reasoning_equals);

  const endpoints = normalizeStringList(payload.endpoints, DEFAULT_CONFIG.endpoints).map(normalizePath);
  if (endpoints.length === 0) {
    throw new Error("endpoints 不能为空");
  }

  const requestHistoryLimit = Number.parseInt(
    `${payload.request_history_limit || DEFAULT_CONFIG.request_history_limit}`,
    10,
  );
  if (!Number.isInteger(requestHistoryLimit) || requestHistoryLimit < 0) {
    throw new Error("History Limit 必须是 0 或正整数；0 表示不裁剪");
  }

  const retryableStatusCodes = normalizeIntegerList(
    payload.retryable_status_codes,
    DEFAULT_CONFIG.retryable_status_codes,
  );
  const retryableErrorMessages = normalizePhraseList(
    payload.retryable_error_messages,
    DEFAULT_CONFIG.retryable_error_messages,
  );
  const upstreamFetchRetryAttempts = normalizePositiveInteger(
    payload.upstream_fetch_retry_attempts,
    DEFAULT_CONFIG.upstream_fetch_retry_attempts,
  );
  const upstreamFetchRetryBackoffMs = normalizeNonNegativeInteger(
    payload.upstream_fetch_retry_backoff_ms,
    DEFAULT_CONFIG.upstream_fetch_retry_backoff_ms,
  );
  if (retryableStatusCodes.length === 0) {
    throw new Error("retryable_status_codes 不能为空");
  }
  if (retryableErrorMessages.length === 0) {
    throw new Error("retryable_error_messages 不能为空");
  }
  if (upstreamFetchRetryAttempts < 1) {
    throw new Error("upstream_fetch_retry_attempts 必须是正整数");
  }
  if (upstreamFetchRetryBackoffMs < 0) {
    throw new Error("upstream_fetch_retry_backoff_ms 不能为负数");
  }

  const envPairs = [
    ["CODEX_RETRY_GATEWAY_LISTEN_HOST", `${payload.listen_host || DEFAULT_CONFIG.listen_host}`.trim()],
    ["CODEX_RETRY_GATEWAY_LISTEN_PORT", `${listenPort}`],
    ["CODEX_RETRY_GATEWAY_UPSTREAM_BASE_URL", upstreamBaseUrl],
    ["CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_MODE", authMode],
    ["CODEX_RETRY_GATEWAY_REASONING_MATCH_MODE", reasoningMatchMode],
    ["CODEX_RETRY_GATEWAY_REASONING_EQUALS", reasoningEquals.join(",")],
    ["CODEX_RETRY_GATEWAY_RETRYABLE_STATUS_CODES", retryableStatusCodes.join(",")],
    ["CODEX_RETRY_GATEWAY_RETRYABLE_ERROR_MESSAGES", retryableErrorMessages.join("\n")],
    ["CODEX_RETRY_GATEWAY_UPSTREAM_FETCH_RETRY_ATTEMPTS", `${upstreamFetchRetryAttempts}`],
    ["CODEX_RETRY_GATEWAY_UPSTREAM_FETCH_RETRY_BACKOFF_MS", `${upstreamFetchRetryBackoffMs}`],
    ["CODEX_RETRY_GATEWAY_REQUEST_HISTORY_LIMIT", `${requestHistoryLimit}`],
    ["CODEX_RETRY_GATEWAY_ENDPOINTS", endpoints.join(",")],
  ];

  const managementAccessKey = normalizeManagementAccessKey(payload.management_access_key);
  if (managementAccessKey) {
    envPairs.push(["CODEX_RETRY_GATEWAY_MANAGEMENT_ACCESS_KEY", managementAccessKey]);
  }

  const modelRemap = `${payload.model_remap || ""}`.trim();
  if (modelRemap) {
    envPairs.push(["CODEX_RETRY_GATEWAY_MODEL_REMAP", modelRemap]);
  }

  if (authMode === "manual_bearer") {
    const secretPath =
      (await writeManualSecret(name, payload.manual_secret)) ||
      `${payload.manual_secret_file || ""}`.trim() ||
      defaultManualSecretPath(name);
    if (!fs.existsSync(secretPath)) {
      throw new Error("manual_bearer 需要手动填入一次 token/password 后才能保存");
    }
    envPairs.push(["CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_FILE", secretPath]);
  } else if (authMode === "fixed_bearer") {
    envPairs.push([
      "CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_ENV",
      `${payload.auth_env || DEFAULT_CONFIG.upstream_auth_env}`.trim(),
    ]);
    if (`${payload.auth_file || ""}`.trim()) {
      envPairs.push(["CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_FILE", `${payload.auth_file}`.trim()]);
    }
  } else if (authMode === "auth_json") {
    if (`${payload.auth_json_path || ""}`.trim()) {
      envPairs.push(["CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_JSON_PATH", `${payload.auth_json_path}`.trim()]);
    }
    envPairs.push([
      "CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_JSON_KEY",
      `${payload.auth_json_key || DEFAULT_CONFIG.upstream_auth_json_key}`.trim(),
    ]);
  }

  const lines = [
    "# Managed by codex-retry-gateway UI.",
    "# Do not put raw sk-* secrets here; use env/file/auth.json references.",
    ...envPairs.map(([key, value]) => `${key}=${serializeEnvValue(value)}`),
    "",
  ];

  return {
    name,
    content: lines.join("\n"),
  };
}

async function buildImageProfileEnvText(payload) {
  assertNoInlineProfileSecret(payload, [
    "base_url",
    "auth_env",
    "auth_file",
    "auth_json_path",
    "auth_json_key",
  ]);

  const name = `${payload?.name || ""}`.trim();
  validateProfileName(name);

  const baseUrl = `${payload?.base_url || ""}`.trim();
  if (baseUrl) {
    try {
      new URL(baseUrl);
    } catch {
      throw new Error("图片上游 Base URL 必须是合法 URL");
    }
  }

  const authMode = normalizeAuthMode(payload?.auth_mode || DEFAULT_CONFIG.image_auth_mode);
  const envPairs = [
    ["CODEX_RETRY_GATEWAY_IMAGE_BASE_URL", baseUrl],
    ["CODEX_RETRY_GATEWAY_IMAGE_AUTH_MODE", authMode],
  ];

  if (baseUrl && authMode === "manual_bearer") {
    const secretPath =
      (await writeImageManualSecret(name, payload?.manual_secret)) ||
      `${payload?.manual_secret_file || ""}`.trim() ||
      defaultImageManualSecretPath(name);
    if (!fs.existsSync(secretPath)) {
      throw new Error("图片 manual_bearer 需要手动填入一次 API key 后才能保存");
    }
    envPairs.push(["CODEX_RETRY_GATEWAY_IMAGE_AUTH_FILE", secretPath]);
  } else if (baseUrl && authMode === "fixed_bearer") {
    envPairs.push([
      "CODEX_RETRY_GATEWAY_IMAGE_AUTH_ENV",
      `${payload?.auth_env || DEFAULT_CONFIG.image_auth_env}`.trim(),
    ]);
    if (`${payload?.auth_file || ""}`.trim()) {
      envPairs.push(["CODEX_RETRY_GATEWAY_IMAGE_AUTH_FILE", `${payload.auth_file}`.trim()]);
    }
  } else if (baseUrl && authMode === "auth_json") {
    if (`${payload?.auth_json_path || ""}`.trim()) {
      envPairs.push(["CODEX_RETRY_GATEWAY_IMAGE_AUTH_JSON_PATH", `${payload.auth_json_path}`.trim()]);
    }
    envPairs.push([
      "CODEX_RETRY_GATEWAY_IMAGE_AUTH_JSON_KEY",
      `${payload?.auth_json_key || DEFAULT_CONFIG.image_auth_json_key}`.trim(),
    ]);
  }

  return {
    name,
    content: [
      "# Managed by codex-retry-gateway image profile UI.",
      "# Do not put raw sk-* secrets here; use env/file/auth.json references.",
      ...envPairs.map(([key, value]) => `${key}=${serializeEnvValue(value)}`),
      "",
    ].join("\n"),
  };
}

async function writeProfile(runtime, payload) {
  const { name, content } = await buildProfileEnvText(payload);
  await mkdir(runtime.paths.profilesDir, { recursive: true });
  const profilePath = path.join(runtime.paths.profilesDir, `${name}.env`);
  await writeFile(profilePath, content, { encoding: "utf8", mode: 0o600 });
  return {
    name,
    file_path: profilePath,
  };
}

async function writeImageProfile(runtime, payload) {
  const { name, content } = await buildImageProfileEnvText(payload);
  await mkdir(runtime.paths.imageProfilesDir, { recursive: true });
  const profilePath = path.join(runtime.paths.imageProfilesDir, `${name}.env`);
  await writeFile(profilePath, content, { encoding: "utf8", mode: 0o600 });
  return {
    name,
    file_path: profilePath,
  };
}

function buildMetricsSnapshot(monitor) {
  const reasoning516Count = monitor.observed_reasoning_counts["516"] || 0;
  const inspectedResponseCount = monitor.inspected_response_count;
  const reasoningEntries = Object.entries(monitor.observed_reasoning_counts).sort((left, right) => {
    const countDelta = Number(right[1] || 0) - Number(left[1] || 0);
    if (countDelta !== 0) {
      return countDelta;
    }
    return Number(left[0] || 0) - Number(right[0] || 0);
  });
  const visibleReasoningEntries = reasoningEntries.slice(0, STATUS_REASONING_COUNT_LIMIT);
  return {
    started_at: monitor.started_at,
    persistent_since: monitor.persistent_since,
    total_proxy_request_count: monitor.total_proxy_request_count,
    inspected_response_count: inspectedResponseCount,
    matched_response_count: monitor.matched_response_count,
    reasoning_516_count: reasoning516Count,
    reasoning_516_ratio:
      inspectedResponseCount === 0 ? 0 : reasoning516Count / inspectedResponseCount,
    token_totals: { ...monitor.token_totals },
    observed_reasoning_counts: Object.fromEntries(visibleReasoningEntries),
    observed_reasoning_counts_total_keys: reasoningEntries.length,
    observed_reasoning_counts_omitted: Math.max(
      0,
      reasoningEntries.length - visibleReasoningEntries.length,
    ),
  };
}

function buildLogsSnapshot(monitor, sinceSeq = null) {
  const entries = Number.isInteger(sinceSeq)
    ? monitor.log_entries.filter((entry) => entry.seq > sinceSeq)
    : monitor.log_entries;

  return {
    total_entries: monitor.log_entries.length,
    latest_seq: monitor.next_log_seq - 1,
    entries,
  };
}

async function buildPersistentLogsSnapshot(runtime, sinceSeq = null, limit = 500) {
  const safeLimit = Number.isInteger(limit) && limit > 0 ? Math.min(limit, 1000) : 500;
  const text = runtime.logPath ? await readOptionalText(runtime.logPath) : null;
  if (!text) {
    return buildLogsSnapshot(runtime.monitor, sinceSeq);
  }

  const allEntries = text
    .split(/\r?\n/)
    .filter(Boolean)
    .map((line, index) => parseLogLine(line, index + 1));
  const entries = Number.isInteger(sinceSeq)
    ? allEntries.filter((entry) => entry.seq > sinceSeq)
    : allEntries.slice(-safeLimit);

  return {
    total_entries: allEntries.length,
    latest_seq: allEntries.length,
    entries,
  };
}

function buildRequestsSnapshot(monitor, limit = 50) {
  const safeLimit = Number.isInteger(limit) && limit > 0 ? Math.min(limit, 500) : 50;
  const entries = monitor.request_entries.slice(-safeLimit).reverse();
  return {
    total_entries: monitor.request_entries.length,
    latest_seq: monitor.next_request_seq - 1,
    entries,
  };
}

async function buildPersistentRequestsSnapshot(runtime, { limit = 50, offset = 0, query = "", filter = "all" } = {}) {
  const safeLimit = Number.isInteger(limit) && limit > 0 ? Math.min(limit, 500) : 50;
  const safeOffset = Number.isInteger(offset) && offset > 0 ? offset : 0;
  if (!runtime.requestsDb) {
    const entries = await readJsonlFile(runtime.paths.requestsPath);
    return {
      total_entries: entries.length,
      latest_seq: entries.reduce((maxSeq, entry) => {
        return Math.max(maxSeq, Number.isInteger(entry.seq) ? entry.seq : maxSeq);
      }, 0),
      entries: entries.slice(-safeLimit).reverse().map((entry) => decorateRequestEntryWithThreadRule(runtime, entry)),
    };
  }

  const { whereSql, params } = buildRequestQueryFilters({ query, filter });
  const totalRow = runtime.requestsDb.prepare(`SELECT COUNT(*) AS count FROM requests ${whereSql}`).get(params);
  const latestRow = runtime.requestsDb.prepare("SELECT MAX(seq) AS latest_seq FROM requests").get();
  const rows = runtime.requestsDb.prepare(`
    SELECT payload_json
    FROM requests
    ${whereSql}
    ORDER BY seq DESC
    LIMIT @limit OFFSET @offset
  `).all({
    ...params,
    limit: safeLimit,
    offset: safeOffset,
  });

  return {
    total_entries: totalRow?.count || 0,
    latest_seq: latestRow?.latest_seq || 0,
    entries: rows.map(parseRequestRowPayload).filter(Boolean).map((entry) => decorateRequestEntryWithThreadRule(runtime, entry)),
  };
}

function buildRequestEntry({ seq, startedAt, startedMs, req, pathname, requestJson, profileName }) {
  return {
    seq,
    request_id: null,
    response_id: null,
    thread_id: firstNonEmptyString(
      extractRequestThreadId(requestJson),
      extractHeaderThreadId(req?.headers),
    ),
    lifecycle_state: "sent",
    started_at: startedAt.toISOString(),
    first_response_at: null,
    first_response_delay_ms: null,
    last_activity_at: null,
    finished_at: null,
    duration_ms: null,
    profile_name: profileName || "default",
    method: req.method,
    path: pathname,
    request_body_bytes: null,
    response_bytes_received: 0,
    model: requestJson?.model || null,
    requested_model: requestJson?.model || null,
    forwarded_model: requestJson?.model || null,
    reasoning_effort: extractRequestReasoningEffort(requestJson),
    reasoning_summary: extractRequestReasoningSummary(requestJson),
    request_stream: Boolean(requestJson?.stream),
    response_stream: false,
    stream_chunk_count: 0,
    usage_last_updated_at: null,
    upstream_attempt_count: 0,
    reasoning_guard_enabled: true,
    reasoning_guard_thread_override: "default",
    reasoning_retry_enabled: false,
    reasoning_retry_query_count: 0,
    reasoning_retry_round_count: 0,
    reasoning_retry_current_round: null,
    reasoning_retry_current_width: 0,
    reasoning_retry_current_firsts: [],
    reasoning_retry_winner_round: null,
    reasoning_retry_winner_slot: null,
    reasoning_retry_stop_reason: null,
    reasoning_retry_thread_mode: "disabled",
    reasoning_retry_extra_inspected_count: 0,
    reasoning_retry_extra_matched_count: 0,
    reasoning_retry_extra_usage: null,
    reasoning_retry_extra_reasoning_counts: {},
    inspected: false,
    matched: false,
    status_code: null,
    upstream_status_code: null,
    upstream: null,
    reasoning_tokens: null,
    usage: null,
    error: null,
    _started_ms: startedMs,
  };
}

function markRequestFirstResponse(entry, at = new Date()) {
  if (entry.first_response_at) {
    return false;
  }
  const firstAt = at instanceof Date ? at : new Date(at);
  const firstMs = firstAt.getTime();
  entry.first_response_at = firstAt.toISOString();
  entry.first_response_delay_ms = Number.isFinite(entry._started_ms)
    ? Math.max(0, firstMs - entry._started_ms)
    : null;
  entry.last_activity_at = firstAt.toISOString();
  entry.lifecycle_state = "receive_first";
  entry._first_response_observer?.({
    first_response_at: entry.first_response_at,
    first_response_delay_ms: entry.first_response_delay_ms,
  });
  return true;
}

const STREAM_PROGRESS_PERSIST_INTERVAL_MS = 1000;

function updateStreamingProgress(entry, { chunkBytes = 0, usage = null, reasoning = null, at = new Date() } = {}) {
  const observedAt = at instanceof Date ? at : new Date(at);
  const observedAtIso = observedAt.toISOString();

  entry.last_activity_at = observedAtIso;
  entry.lifecycle_state = "streaming";

  if (chunkBytes > 0) {
    entry.stream_chunk_count = (entry.stream_chunk_count || 0) + 1;
    entry.response_bytes_received = (entry.response_bytes_received || 0) + chunkBytes;
  }

  if (usage) {
    entry.usage = mergeUsageSnapshots(entry.usage, usage);
    entry.usage_last_updated_at = observedAtIso;
  }

  if (Number.isInteger(reasoning)) {
    entry.reasoning_tokens = reasoning;
  }
}

function persistStreamingProgress(runtime, entry, { force = false, usageUpdated = false } = {}, at = new Date()) {
  const observedAt = at instanceof Date ? at : new Date(at);
  const nowMs = observedAt.getTime();
  const lastPersistedMs = Number.isFinite(entry._last_stream_persisted_ms)
    ? entry._last_stream_persisted_ms
    : 0;
  if (!force && !usageUpdated && nowMs - lastPersistedMs < STREAM_PROGRESS_PERSIST_INTERVAL_MS) {
    return false;
  }
  entry._last_stream_persisted_ms = nowMs;
  upsertRequestEntry(runtime, entry);
  return true;
}

function finalizeRequestEntry(entry, result = {}) {
  const finishedAt = new Date();
  const startedMs = entry._started_ms;
  delete entry._started_ms;
  delete entry._last_stream_persisted_ms;
  return {
    ...entry,
    ...result,
    lifecycle_state: "finish",
    finished_at: finishedAt.toISOString(),
    duration_ms: Number.isFinite(startedMs) ? Math.max(0, Date.now() - startedMs) : null,
  };
}

async function loadConfig(configPath) {
  const content = await readFile(configPath, "utf8");
  const loaded = JSON.parse(content);
  const config = { ...DEFAULT_CONFIG, ...loaded };
  config.image_profile_name = /^[A-Za-z0-9_.-]+$/.test(`${config.image_profile_name || ""}`)
    ? `${config.image_profile_name}`
    : "";
  config.model_remap_map = parseModelRemapMap(config.model_remap);
  config.endpoints = normalizeStringList(config.endpoints, DEFAULT_CONFIG.endpoints).map(normalizePath);
  config.reasoning_match_mode = normalizeReasoningMatchMode(config.reasoning_match_mode);
  config.reasoning_equals = normalizeReasoningEquals(
    config.reasoning_equals,
    DEFAULT_CONFIG.reasoning_equals,
  );
  config.retryable_status_codes = normalizeIntegerList(
    config.retryable_status_codes,
    DEFAULT_CONFIG.retryable_status_codes,
  );
  config.retryable_error_messages = normalizePhraseList(
    config.retryable_error_messages,
    DEFAULT_CONFIG.retryable_error_messages,
  );
  config.management_access_key = normalizeManagementAccessKey(config.management_access_key);
  config.upstream_fetch_retry_attempts = normalizePositiveInteger(
    config.upstream_fetch_retry_attempts,
    DEFAULT_CONFIG.upstream_fetch_retry_attempts,
  );
  config.upstream_fetch_retry_backoff_ms = normalizeNonNegativeInteger(
    config.upstream_fetch_retry_backoff_ms,
    DEFAULT_CONFIG.upstream_fetch_retry_backoff_ms,
  );
  config.image_base_url = `${config.image_base_url || ""}`.trim();
  if (config.image_base_url) {
    try {
      new URL(config.image_base_url);
    } catch {
      throw new Error("配置中的 image_base_url 必须是合法 URL");
    }
  }
  if (!config.upstream_base_url) {
    throw new Error("配置缺少 upstream_base_url");
  }
  return config;
}

function buildRuntimePaths(configPath, logPath) {
  const configDirectory = path.dirname(configPath);
  const stateRoot = path.dirname(configDirectory);
  const homeDir = process.env.HOME || "";
  return {
    stateRoot,
    statePath: path.join(stateRoot, "state.json"),
    pidPath: path.join(stateRoot, "gateway.pid"),
    profilesDir: path.join(homeDir, ".config", "codex-retry-gateway", "profiles"),
    imageProfilesDir: path.join(homeDir, ".config", "codex-retry-gateway", "image-profiles"),
    configPath,
    logPath,
    threadRulesPath: path.join(stateRoot, "thread-rules.json"),
    requestsPath: path.join(stateRoot, "logs", "requests.jsonl"),
    requestsDbPath: path.join(stateRoot, "logs", "requests.sqlite"),
  };
}

async function readOptionalJson(jsonPath) {
  try {
    const content = await readFile(jsonPath, "utf8");
    return JSON.parse(content);
  } catch {
    return null;
  }
}

function normalizeThreadRuleEntry(value) {
  const threadId = firstNonEmptyString(value?.thread_id, value?.threadId);
  if (!threadId || value?.reasoning_intercept_enabled === undefined) {
    return null;
  }
  return {
    thread_id: threadId,
    reasoning_intercept_enabled: Boolean(value.reasoning_intercept_enabled),
    updated_at: firstNonEmptyString(value?.updated_at) || new Date().toISOString(),
  };
}

function normalizeThreadRulesDocument(payload) {
  const rules = Array.isArray(payload)
    ? payload
    : Array.isArray(payload?.rules)
      ? payload.rules
      : [];
  const entries = [];
  for (const rule of rules) {
    const normalized = normalizeThreadRuleEntry(rule);
    if (normalized) {
      entries.push(normalized);
    }
  }
  return entries;
}

function compareThreadRuleEntries(left, right) {
  const leftTime = Date.parse(left?.updated_at || "") || 0;
  const rightTime = Date.parse(right?.updated_at || "") || 0;
  if (rightTime !== leftTime) {
    return rightTime - leftTime;
  }
  return `${left?.thread_id || ""}`.localeCompare(`${right?.thread_id || ""}`);
}

function buildThreadRulesMap(entries = []) {
  const map = new Map();
  for (const entry of entries) {
    map.set(entry.thread_id, entry);
  }
  return map;
}

async function loadThreadRules(filePath) {
  const payload = await readOptionalJson(filePath);
  return buildThreadRulesMap(normalizeThreadRulesDocument(payload));
}

function serializeThreadRules(threadRules) {
  const rules = Array.from(threadRules?.values?.() || [])
    .map((entry) => ({
      thread_id: entry.thread_id,
      reasoning_intercept_enabled: Boolean(entry.reasoning_intercept_enabled),
      updated_at: entry.updated_at || new Date().toISOString(),
    }))
    .sort(compareThreadRuleEntries);
  return {
    version: 1,
    rules,
  };
}

async function writeThreadRules(filePath, threadRules) {
  await mkdir(path.dirname(filePath), { recursive: true });
  await writeFile(filePath, `${JSON.stringify(serializeThreadRules(threadRules), null, 2)}\n`, "utf8");
}

function listThreadRules(runtime) {
  return serializeThreadRules(runtime.threadRules).rules;
}

function getThreadReasoningState(runtime, threadId) {
  const normalizedThreadId = firstNonEmptyString(threadId);
  if (!normalizedThreadId) {
    return {
      thread_id: null,
      reasoning_intercept_enabled: true,
      override: "default",
      updated_at: null,
    };
  }
  const entry = runtime.threadRules?.get(normalizedThreadId) || null;
  if (!entry) {
    return {
      thread_id: normalizedThreadId,
      reasoning_intercept_enabled: true,
      override: "default",
      updated_at: null,
    };
  }
  return {
    thread_id: normalizedThreadId,
    reasoning_intercept_enabled: Boolean(entry.reasoning_intercept_enabled),
    override: entry.reasoning_intercept_enabled ? "enabled" : "disabled",
    updated_at: entry.updated_at || null,
  };
}

function applyThreadReasoningState(runtime, requestEntry, pathname = requestEntry?.path) {
  if (!requestEntry || typeof requestEntry !== "object") {
    return requestEntry;
  }
  const threadState = getThreadReasoningState(runtime, requestEntry.thread_id);
  requestEntry.reasoning_guard_enabled = threadState.reasoning_intercept_enabled;
  requestEntry.reasoning_guard_thread_override = threadState.override;
  const retryPath = isResponsesReasoningRetryPath(pathname);
  requestEntry.reasoning_retry_enabled = retryPath && threadState.reasoning_intercept_enabled;
  if (!retryPath) {
    requestEntry.reasoning_retry_thread_mode = "disabled";
    return requestEntry;
  }
  if (!threadState.reasoning_intercept_enabled) {
    requestEntry.reasoning_retry_thread_mode = "thread_guard_disabled";
    if (
      !requestEntry.reasoning_retry_stop_reason ||
      requestEntry.reasoning_retry_stop_reason === "missing_thread_id"
    ) {
      requestEntry.reasoning_retry_stop_reason = "thread_guard_disabled";
    }
    return requestEntry;
  }
  if (requestEntry.thread_id) {
    requestEntry.reasoning_retry_thread_mode = "thread_id";
    if (requestEntry.reasoning_retry_stop_reason === "thread_guard_disabled") {
      requestEntry.reasoning_retry_stop_reason = null;
    }
    return requestEntry;
  }
  requestEntry.reasoning_retry_thread_mode = "missing_thread_id";
  if (!requestEntry.reasoning_retry_stop_reason) {
    requestEntry.reasoning_retry_stop_reason = "missing_thread_id";
  }
  return requestEntry;
}

function decorateRequestEntryWithThreadRule(runtime, entry) {
  if (!entry || typeof entry !== "object") {
    return entry;
  }
  const threadState = getThreadReasoningState(runtime, entry.thread_id);
  return {
    ...entry,
    reasoning_guard_enabled: threadState.reasoning_intercept_enabled,
    reasoning_guard_thread_override: threadState.override,
  };
}

function normalizeThreadRuleUpdatePayload(payload) {
  const threadId = firstNonEmptyString(payload?.thread_id, payload?.threadId);
  if (!threadId) {
    throw new Error("缺少 thread_id");
  }
  if (payload?.reasoning_intercept_enabled === undefined) {
    throw new Error("缺少 reasoning_intercept_enabled");
  }
  return {
    thread_id: threadId,
    reasoning_intercept_enabled: Boolean(payload.reasoning_intercept_enabled),
    updated_at: new Date().toISOString(),
  };
}

async function upsertThreadRule(runtime, payload) {
  const entry = normalizeThreadRuleUpdatePayload(payload);
  runtime.threadRules.set(entry.thread_id, entry);
  await writeThreadRules(runtime.paths.threadRulesPath, runtime.threadRules);
  return entry;
}

async function deleteThreadRule(runtime, threadId) {
  const normalizedThreadId = firstNonEmptyString(threadId);
  if (!normalizedThreadId) {
    throw new Error("缺少 thread_id");
  }
  const previous = runtime.threadRules.get(normalizedThreadId) || null;
  runtime.threadRules.delete(normalizedThreadId);
  await writeThreadRules(runtime.paths.threadRulesPath, runtime.threadRules);
  return previous;
}

async function readOptionalText(textPath) {
  try {
    return await readFile(textPath, "utf8");
  } catch {
    return null;
  }
}

function normalizeAuthMode(value) {
  const mode = `${value || "passthrough"}`.trim().toLowerCase();
  if (["passthrough", "fixed_bearer", "manual_bearer", "auth_json"].includes(mode)) {
    return mode;
  }
  return "passthrough";
}

function sanitizeConfigForStatus(config) {
  const {
    management_access_key,
    upstream_auth_file,
    upstream_auth_json_path,
    upstream_auth_env,
    upstream_auth_json_key,
    image_auth_file,
    image_auth_json_path,
    image_auth_env,
    image_auth_json_key,
    model_remap_map,
    ...rest
  } = config;

  return {
    ...rest,
    management_access_key_configured: Boolean(management_access_key),
    upstream_auth_env: upstream_auth_env || null,
    upstream_auth_file: upstream_auth_file ? "[configured]" : "",
    upstream_auth_json_path: upstream_auth_json_path ? "[configured]" : "",
    upstream_auth_json_key: upstream_auth_json_key || null,
    image_auth_env: image_auth_env || null,
    image_auth_file: image_auth_file ? "[configured]" : "",
    image_auth_json_path: image_auth_json_path ? "[configured]" : "",
    image_auth_json_key: image_auth_json_key || null,
  };
}

function remapRequestModel(config, requestJson) {
  if (!requestJson || typeof requestJson !== "object") {
    return { requestJson, remapped: false, forwardedModel: null };
  }
  const requestedModel = `${requestJson.model || ""}`.trim();
  if (!requestedModel) {
    return { requestJson, remapped: false, forwardedModel: null };
  }
  const forwardedModel = config.model_remap_map?.[requestedModel];
  if (!forwardedModel || forwardedModel === requestedModel) {
    return { requestJson, remapped: false, forwardedModel: requestedModel };
  }
  return {
    requestJson: {
      ...requestJson,
      model: forwardedModel,
    },
    remapped: true,
    forwardedModel,
  };
}

async function resolveUpstreamAuth(config, authScope = "upstream") {
  const mode = normalizeAuthMode(config.upstream_auth_mode);
  if (mode === "passthrough") {
    return { mode, authorization: null, source: "passthrough" };
  }

  let token = "";
  let source = "missing";
  if (mode === "fixed_bearer") {
    const envName = config.upstream_auth_env || DEFAULT_CONFIG.upstream_auth_env;
    token = envName ? `${process.env[envName] || ""}`.trim() : "";
    source = token ? "env" : "missing";
    if (!token && config.upstream_auth_file) {
      token = `${(await readOptionalText(config.upstream_auth_file)) || ""}`.trim();
      source = token ? "file" : "file_empty";
    }
  } else if (mode === "manual_bearer") {
    if (config.upstream_auth_file) {
      token = `${(await readOptionalText(config.upstream_auth_file)) || ""}`.trim();
      source = token ? "manual_file" : "manual_file_empty";
    }
  } else if (mode === "auth_json") {
    const authPath = config.upstream_auth_json_path || path.join(process.env.HOME || "", ".codex", "auth.json");
    const key = config.upstream_auth_json_key || DEFAULT_CONFIG.upstream_auth_json_key;
    const authJson = await readOptionalJson(authPath);
    token = `${authJson?.[key] || ""}`.trim();
    source = token ? "auth_json" : "auth_json_missing";
  }

  if (!token) {
    throw new Error(`${authScope}_auth_mode=${mode} requires a configured token source`);
  }

  const authorization = token.toLowerCase().startsWith("bearer ") ? token : `Bearer ${token}`;
  return { mode, authorization, source };
}

async function writeConfig(configPath, config) {
  await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
}

async function updateRuntimeState(runtime, updates) {
  const current = await readOptionalJson(runtime.paths.statePath);
  if (!current) {
    return;
  }
  await writeFile(
    runtime.paths.statePath,
    `${JSON.stringify({ ...current, ...updates }, null, 2)}\n`,
    "utf8",
  );
}

async function listProfiles(runtime) {
  let files = [];
  try {
    files = await readdir(runtime.paths.profilesDir, { withFileTypes: true });
  } catch {
    files = [];
  }

  const activeProfile = runtime.config.profile_name || "default";
  const profiles = [];
  for (const file of files) {
    if (!file.isFile()) {
      continue;
    }
    const name = getProfileNameFromFile(file.name);
    if (!name) {
      continue;
    }
    const filePath = path.join(runtime.paths.profilesDir, file.name);
    const env = parseEnvText((await readOptionalText(filePath)) || "");
    const form = buildProfileFormModel(env);
    profiles.push({
      name,
      active: name === activeProfile,
      file_path: filePath,
      summary: {
        listen_host: form.listen_host,
        listen_port: form.listen_port,
        upstream_base_url: form.upstream_base_url,
        auth_mode: form.auth_mode,
        auth_env: redactProfileValue(
          "CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_ENV",
          form.auth_env,
        ),
        auth_file: form.auth_file ? "[configured]" : "",
        auth_json_path: form.auth_json_path ? "[configured]" : "",
        auth_json_key: redactProfileValue(
          "CODEX_RETRY_GATEWAY_UPSTREAM_AUTH_JSON_KEY",
          form.auth_json_key,
        ),
        request_history_limit: form.request_history_limit,
        model_remap: form.model_remap || "",
        auth_source: summarizeProfileAuthSource(env),
        reasoning_match_mode: form.reasoning_match_mode,
        reasoning_equals: form.reasoning_equals,
      },
      form,
    });
  }
  profiles.sort((left, right) => left.name.localeCompare(right.name));
  return profiles;
}

const IMAGE_PROFILE_ENV_KEYS = [
  "CODEX_RETRY_GATEWAY_IMAGE_BASE_URL",
  "CODEX_RETRY_GATEWAY_IMAGE_AUTH_MODE",
  "CODEX_RETRY_GATEWAY_IMAGE_AUTH_ENV",
  "CODEX_RETRY_GATEWAY_IMAGE_AUTH_FILE",
  "CODEX_RETRY_GATEWAY_IMAGE_AUTH_JSON_PATH",
  "CODEX_RETRY_GATEWAY_IMAGE_AUTH_JSON_KEY",
];

function hasLegacyImageProfileConfig(env) {
  return Boolean(`${env?.CODEX_RETRY_GATEWAY_IMAGE_BASE_URL || ""}`.trim());
}

function legacyImageProfileEnvFromConfig(config) {
  const baseUrl = `${config?.image_base_url || ""}`.trim();
  if (!baseUrl) {
    return {};
  }
  return {
    CODEX_RETRY_GATEWAY_IMAGE_BASE_URL: baseUrl,
    CODEX_RETRY_GATEWAY_IMAGE_AUTH_MODE: config?.image_auth_mode || DEFAULT_CONFIG.image_auth_mode,
    CODEX_RETRY_GATEWAY_IMAGE_AUTH_ENV: config?.image_auth_env || "",
    CODEX_RETRY_GATEWAY_IMAGE_AUTH_FILE: config?.image_auth_file || "",
    CODEX_RETRY_GATEWAY_IMAGE_AUTH_JSON_PATH: config?.image_auth_json_path || "",
    CODEX_RETRY_GATEWAY_IMAGE_AUTH_JSON_KEY: config?.image_auth_json_key || "",
  };
}

function buildLegacyImageProfileEnvText(env) {
  const pairs = IMAGE_PROFILE_ENV_KEYS
    .filter((key) => env?.[key] !== undefined)
    .map((key) => [key, env[key]]);
  return [
    "# Migrated from a legacy text profile by codex-retry-gateway.",
    "# Image configuration is now independent from text profiles.",
    ...pairs.map(([key, value]) => `${key}=${serializeEnvValue(value)}`),
    "",
  ].join("\n");
}

async function migrateLegacyImageProfile(runtime, textProfileName, textEnv = null, legacyConfig = null) {
  validateProfileName(textProfileName);
  const imageProfilePath = path.join(runtime.paths.imageProfilesDir, `${textProfileName}.env`);
  if (fs.existsSync(imageProfilePath)) {
    return { name: textProfileName, file_path: imageProfilePath, migrated: false };
  }

  let env = textEnv;
  if (!env) {
    const textProfilePath = path.join(runtime.paths.profilesDir, `${textProfileName}.env`);
    if (fs.existsSync(textProfilePath)) {
      env = parseEnvText((await readOptionalText(textProfilePath)) || "");
    } else {
      env = {};
    }
  }
  const sourceEnv = hasLegacyImageProfileConfig(env)
    ? env
    : legacyImageProfileEnvFromConfig(legacyConfig);
  if (!hasLegacyImageProfileConfig(sourceEnv)) {
    return null;
  }

  await mkdir(runtime.paths.imageProfilesDir, { recursive: true });
  await writeFile(imageProfilePath, buildLegacyImageProfileEnvText(sourceEnv), {
    encoding: "utf8",
    mode: 0o600,
  });
  return { name: textProfileName, file_path: imageProfilePath, migrated: true };
}

async function listImageProfiles(runtime) {
  let files = [];
  try {
    files = await readdir(runtime.paths.imageProfilesDir, { withFileTypes: true });
  } catch {
    files = [];
  }

  const activeProfile = `${runtime.config.image_profile_name || ""}`.trim();
  const profiles = [];
  for (const file of files) {
    if (!file.isFile()) {
      continue;
    }
    const name = getProfileNameFromFile(file.name);
    if (!name) {
      continue;
    }
    const filePath = path.join(runtime.paths.imageProfilesDir, file.name);
    const env = parseEnvText((await readOptionalText(filePath)) || "");
    const form = buildImageProfileFormModel(env);
    profiles.push({
      name,
      active: name === activeProfile,
      file_path: filePath,
      summary: {
        base_url: form.base_url,
        auth_mode: form.auth_mode,
        auth_env: redactProfileValue("CODEX_RETRY_GATEWAY_IMAGE_AUTH_ENV", form.auth_env),
        auth_file: form.auth_file ? "[configured]" : "",
        manual_secret_file: form.manual_secret_file ? "[configured]" : "",
        auth_json_path: form.auth_json_path ? "[configured]" : "",
        auth_json_key: redactProfileValue(
          "CODEX_RETRY_GATEWAY_IMAGE_AUTH_JSON_KEY",
          form.auth_json_key,
        ),
        auth_source: form.base_url ? summarizeImageProfileAuthSource(env) : "disabled",
      },
      form,
    });
  }
  profiles.sort((left, right) => left.name.localeCompare(right.name));
  return profiles;
}

function runDetached(command, args) {
  const child = spawn(command, args, {
    detached: true,
    stdio: "ignore",
    windowsHide: true,
  });
  child.unref();
  return child.pid;
}

async function triggerProfileSwitch(runtime, profileName) {
  if (!/^[A-Za-z0-9_.-]+$/.test(profileName)) {
    throw new Error("profile 名称只能包含字母、数字、下划线、点和短横线");
  }

  const profilePath = path.join(runtime.paths.profilesDir, `${profileName}.env`);
  if (!fs.existsSync(profilePath)) {
    throw new Error(`profile 不存在: ${profileName}`);
  }

  const currentUnit = `codex-retry-gateway@${runtime.config.profile_name || "default"}.service`;
  const targetUnit = `codex-retry-gateway@${profileName}.service`;
  const switchScript = [
    "set -e",
    `systemctl --user disable --now ${currentUnit}`,
    `systemctl --user enable --now ${targetUnit}`,
  ].join("\n");

  const unitName = `codex-retry-gateway-switch-${Date.now()}`;
  const pid = runDetached("systemd-run", [
    "--user",
    "--collect",
    `--unit=${unitName}`,
    "--on-active=1s",
    "/usr/bin/env",
    "bash",
    "-lc",
    switchScript,
  ]);

  return {
    profile: profileName,
    current_unit: currentUnit,
    target_unit: targetUnit,
    switch_unit: `${unitName}.service`,
    pid,
  };
}

async function applyProfileConfig(runtime, profileName) {
  const { profilePath, config } = await loadProfileConfigForProbe(runtime, profileName);
  if (!canHotSwapProfile(runtime.config, config)) {
    throw new Error("该 profile 的监听地址或端口与当前实例不同，暂不支持无重启热切换");
  }

  runtime.config = {
    ...config,
    model_remap_map: parseModelRemapMap(config.model_remap),
  };

  await writeConfig(runtime.configPath, runtime.config);
  await updateRuntimeState(runtime, {
    profile_name: runtime.config.profile_name || "default",
    profile_env_path: profilePath,
    gateway_base_url: `http://${runtime.config.listen_host}:${runtime.config.listen_port}`,
    last_started_at: new Date().toISOString(),
  });
  runtime.logger(
    `[profile] hot-swapped profile=${runtime.config.profile_name || "default"} auth=${normalizeAuthMode(runtime.config.upstream_auth_mode)} upstream=${runtime.config.upstream_base_url}`,
  );

  return {
    profile: runtime.config.profile_name || "default",
    profile_env_path: profilePath,
    hot_swapped: true,
    listen: `${runtime.config.listen_host}:${runtime.config.listen_port}`,
    upstream_base_url: runtime.config.upstream_base_url,
  };
}

async function loadProfileConfigForProbe(runtime, profileName) {
  validateProfileName(profileName);
  const profilePath = path.join(runtime.paths.profilesDir, `${profileName}.env`);
  if (!fs.existsSync(profilePath)) {
    throw new Error(`profile 不存在: ${profileName}`);
  }
  const env = parseEnvText((await readOptionalText(profilePath)) || "");
  const config = buildConfigFromProfileEnv(profileName, env, imageConfigFromConfig(runtime.config));
  if (!config.upstream_base_url) {
    throw new Error(`profile ${profileName} 缺少 upstream_base_url`);
  }
  return { profilePath, env, config };
}

async function loadImageProfileConfigForProbe(runtime, profileName) {
  validateProfileName(profileName);
  const profilePath = path.join(runtime.paths.imageProfilesDir, `${profileName}.env`);
  if (!fs.existsSync(profilePath)) {
    throw new Error(`图片 profile 不存在: ${profileName}`);
  }
  const env = parseEnvText((await readOptionalText(profilePath)) || "");
  const config = buildImageConfigFromProfileEnv(profileName, env);
  return { profilePath, env, config };
}

async function applyImageProfileConfig(runtime, profileName) {
  const { profilePath, config } = await loadImageProfileConfigForProbe(runtime, profileName);
  runtime.config = {
    ...runtime.config,
    ...config,
    model_remap_map: parseModelRemapMap(runtime.config.model_remap),
  };
  await writeConfig(runtime.configPath, runtime.config);
  await updateRuntimeState(runtime, {
    image_profile_name: runtime.config.image_profile_name || "",
    image_profile_env_path: profilePath,
    last_started_at: new Date().toISOString(),
  });
  runtime.logger(
    `[image-profile] hot-swapped profile=${runtime.config.image_profile_name || "-"} auth=${normalizeAuthMode(runtime.config.image_auth_mode)} upstream=${runtime.config.image_base_url || "disabled"}`,
  );
  return {
    image_profile: runtime.config.image_profile_name || "",
    image_profile_env_path: profilePath,
    hot_swapped: true,
    image_base_url: runtime.config.image_base_url || "",
  };
}

async function ensureActiveImageProfile(runtime) {
  const textProfileName = `${runtime.config.profile_name || "default"}`.trim();
  const state = await readOptionalJson(runtime.paths.statePath);
  const candidates = [
    `${runtime.config.image_profile_name || ""}`.trim(),
    `${state?.image_profile_name || ""}`.trim(),
    textProfileName,
  ].filter((value, index, values) => /^[A-Za-z0-9_.-]+$/.test(value) && values.indexOf(value) === index);

  let selectedName = candidates.find((name) => fs.existsSync(path.join(runtime.paths.imageProfilesDir, `${name}.env`))) || "";
  let migration = null;
  if (!selectedName && /^[A-Za-z0-9_.-]+$/.test(textProfileName)) {
    migration = await migrateLegacyImageProfile(runtime, textProfileName, null, runtime.config);
    selectedName = migration?.name || "";
  }
  if (!selectedName) {
    return null;
  }

  const { profilePath, config } = await loadImageProfileConfigForProbe(runtime, selectedName);
  runtime.config = {
    ...runtime.config,
    ...config,
    model_remap_map: parseModelRemapMap(runtime.config.model_remap),
  };
  await writeConfig(runtime.configPath, runtime.config);
  await updateRuntimeState(runtime, {
    image_profile_name: selectedName,
    image_profile_env_path: profilePath,
  });
  if (migration?.migrated) {
    runtime.logger(
      `[image-profile] migrated legacy text profile=${textProfileName} to image profile=${selectedName}`,
    );
  }
  return {
    image_profile: selectedName,
    image_profile_env_path: profilePath,
    migrated: Boolean(migration?.migrated),
  };
}

async function deleteProfile(runtime, profileName) {
  validateProfileName(profileName);
  const activeProfile = runtime.config.profile_name || "default";
  if (profileName === activeProfile) {
    throw new Error("不能删除当前正在运行的 profile；请先切换到其他 profile");
  }

  const profilePath = path.join(runtime.paths.profilesDir, `${profileName}.env`);
  if (!fs.existsSync(profilePath)) {
    throw new Error(`profile 不存在: ${profileName}`);
  }

  await rm(profilePath, { force: true });
  return {
    name: profileName,
    file_path: profilePath,
  };
}

async function deleteImageProfile(runtime, profileName) {
  validateProfileName(profileName);
  const activeProfile = `${runtime.config.image_profile_name || ""}`.trim();
  if (profileName === activeProfile) {
    throw new Error("不能删除当前正在运行的图片 profile；请先切换到其他图片 profile");
  }
  const profilePath = path.join(runtime.paths.imageProfilesDir, `${profileName}.env`);
  if (!fs.existsSync(profilePath)) {
    throw new Error(`图片 profile 不存在: ${profileName}`);
  }
  await rm(profilePath, { force: true });
  return {
    name: profileName,
    file_path: profilePath,
  };
}

async function readProbeBodySummary(response, maxChars = 400) {
  const contentType = response.headers.get("content-type") || "";
  const text = await response.text();
  let summary = text.slice(0, maxChars);
  if (contentType.includes("application/json")) {
    try {
      const payload = JSON.parse(text);
      if (Array.isArray(payload?.data)) {
        summary = JSON.stringify(payload.data.slice(0, 8).map((item) => item.id ?? item.display_name ?? item), null, 2);
      } else if (payload?.error) {
        summary = JSON.stringify(payload.error);
      } else {
        summary = text.slice(0, maxChars);
      }
    } catch {
      summary = text.slice(0, maxChars);
    }
  }
  return {
    content_type: contentType,
    body_preview: summary,
  };
}

async function probeProfile(runtime, payload) {
  const profileName = `${payload?.profile || ""}`.trim();
  if (!profileName) {
    throw new Error("缺少 profile");
  }

  const { config } = await loadProfileConfigForProbe(runtime, profileName);
  const upstreamAuth = await resolveUpstreamAuth(config);
  const result = {
    profile: profileName,
    upstream_base_url: config.upstream_base_url,
    auth_mode: upstreamAuth.mode,
    auth_source: upstreamAuth.source,
    authorization_configured: Boolean(upstreamAuth.authorization),
    model_remap: config.model_remap || "",
    probes: [],
  };

  const modelsUrl = buildUpstreamUrl(config.upstream_base_url, new URL("http://local/v1/models"));
  const { response: modelsResponse } = await fetchUpstreamWithRetry(modelsUrl, {
    method: "GET",
    headers: cloneHeadersForUpstream({}, upstreamAuth),
  }, config, runtime.logger, { method: "GET", pathname: "/v1/models" });
  result.probes.push({
    kind: "models",
    target: "/v1/models",
    status: modelsResponse.status,
    ...await readProbeBodySummary(modelsResponse, 600),
  });

  const requestedModel = `${payload?.model || ""}`.trim();
  if (requestedModel) {
    const { requestJson, forwardedModel } = remapRequestModel(config, {
      model: requestedModel,
      input: `${payload?.input || "ping"}`,
      max_output_tokens: 1,
      stream: false,
    });
    const responsesUrl = buildUpstreamUrl(config.upstream_base_url, new URL("http://local/v1/responses"));
    const { response: responseProbe } = await fetchUpstreamWithRetry(responsesUrl, {
      method: "POST",
      headers: cloneHeadersForUpstream({ "content-type": "application/json" }, upstreamAuth),
      body: JSON.stringify(requestJson),
    }, config, runtime.logger, { method: "POST", pathname: "/v1/responses" });
    result.probes.push({
      kind: "responses",
      target: "/v1/responses",
      requested_model: requestedModel,
      forwarded_model: forwardedModel || requestedModel,
      status: responseProbe.status,
      ...await readProbeBodySummary(responseProbe, 600),
    });
  }

  return result;
}

async function probeImageProfile(runtime, payload) {
  const profileName = `${payload?.profile || ""}`.trim();
  if (!profileName) {
    throw new Error("缺少图片 profile");
  }

  const { config } = await loadImageProfileConfigForProbe(runtime, profileName);
  if (!config.image_base_url) {
    throw new Error(`图片 profile ${profileName} 未配置 Base URL`);
  }
  const probeConfig = {
    ...runtime.config,
    ...config,
  };
  const upstreamAuth = await resolveUpstreamAuth(
    {
      upstream_auth_mode: config.image_auth_mode,
      upstream_auth_env: config.image_auth_env,
      upstream_auth_file: config.image_auth_file,
      upstream_auth_json_path: config.image_auth_json_path,
      upstream_auth_json_key: config.image_auth_json_key,
    },
    "images",
  );
  const modelsUrl = buildUpstreamUrl(config.image_base_url, new URL("http://local/v1/models"));
  const { response } = await fetchUpstreamWithRetry(modelsUrl, {
    method: "GET",
    headers: cloneHeadersForUpstream({}, upstreamAuth),
  }, probeConfig, runtime.logger, { method: "GET", pathname: "/v1/models" });

  return {
    image_profile: profileName,
    image_base_url: config.image_base_url,
    auth_mode: upstreamAuth.mode,
    auth_source: upstreamAuth.source,
    authorization_configured: Boolean(upstreamAuth.authorization),
    probes: [{
      kind: "models",
      target: "/v1/models",
      status: response.status,
      ...await readProbeBodySummary(response, 600),
    }],
  };
}

function extractProviderBaseUrl(content, providerName) {
  if (!content || !providerName) {
    return null;
  }

  const sectionPattern = new RegExp(
    String.raw`^\[model_providers\.${providerName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\s*$[\s\S]*?(?=^\[|\Z)`,
    "m",
  );
  const sectionMatch = content.match(sectionPattern);
  if (!sectionMatch) {
    return null;
  }

  const baseUrlMatch = sectionMatch[0].match(/^\s*base_url\s*=\s*"([^"]+)"\s*$/m);
  return baseUrlMatch ? baseUrlMatch[1] : null;
}

async function readRuntimeState(runtime) {
  const state = await readOptionalJson(runtime.paths.statePath);
  if (!state) {
    return null;
  }

  let codexCurrentBaseUrl = null;
  if (state.codex_config_path && state.provider_name) {
    try {
      const codexConfig = await readFile(state.codex_config_path, "utf8");
      codexCurrentBaseUrl = extractProviderBaseUrl(codexConfig, state.provider_name);
    } catch {
      codexCurrentBaseUrl = null;
    }
  }

  return {
    ...state,
    codex_current_base_url: codexCurrentBaseUrl,
  };
}

async function restoreRuntimeState(runtime, state) {
  const backupPath = state?.latest_backup_path;
  const codexConfigPath = state?.codex_config_path;

  if (!backupPath || !fs.existsSync(backupPath)) {
    throw new Error(`未找到可恢复备份: ${backupPath || "unknown"}`);
  }
  if (!codexConfigPath) {
    throw new Error("安装状态里缺少 codex_config_path");
  }

  await copyFile(backupPath, codexConfigPath);
  await Promise.all([
    rm(runtime.paths.statePath, { force: true }),
    rm(runtime.paths.pidPath, { force: true }),
  ]);
}

function pickContentEncoding(acceptEncoding = "") {
  const value = `${acceptEncoding}`.toLowerCase();
  if (value.includes("br")) {
    return "br";
  }
  if (value.includes("gzip")) {
    return "gzip";
  }
  return null;
}

function shouldCompressContent(headers = {}) {
  const contentType = `${headers["content-type"] || headers["Content-Type"] || ""}`.toLowerCase();
  return (
    contentType.startsWith("text/") ||
    contentType.includes("javascript") ||
    contentType.includes("json") ||
    contentType.includes("xml") ||
    contentType.includes("svg")
  );
}

function maybeCompressBody(body, headers = {}, acceptEncoding = "") {
  if (!body || body.length < 1024 || !shouldCompressContent(headers)) {
    return { body, encoding: null };
  }
  const encoding = pickContentEncoding(acceptEncoding);
  if (encoding === "br") {
    return { body: zlib.brotliCompressSync(body), encoding };
  }
  if (encoding === "gzip") {
    return { body: zlib.gzipSync(body), encoding };
  }
  return { body, encoding: null };
}

function respondBuffer(res, statusCode, body, headers = {}, acceptEncoding = "") {
  const { body: responseBody, encoding } = maybeCompressBody(body, headers, acceptEncoding);
  res.writeHead(statusCode, {
    "content-length": responseBody.length,
    vary: "accept-encoding",
    ...(encoding ? { "content-encoding": encoding } : {}),
    ...headers,
  });
  res.end(responseBody);
}

function jsonResponse(req, res, statusCode, payload, headers = {}) {
  const body = Buffer.from(JSON.stringify(payload));
  respondBuffer(
    res,
    statusCode,
    body,
    {
      "content-type": "application/json; charset=utf-8",
      ...headers,
    },
    req?.headers?.["accept-encoding"] || "",
  );
}


const STATIC_CONTENT_TYPES = {
  ".html": "text/html; charset=utf-8",
  ".js": "text/javascript; charset=utf-8",
  ".css": "text/css; charset=utf-8",
  ".json": "application/json; charset=utf-8",
  ".svg": "image/svg+xml",
  ".png": "image/png",
  ".ico": "image/x-icon",
  ".woff": "font/woff",
  ".woff2": "font/woff2",
};

function contentTypeForFile(filePath) {
  return STATIC_CONTENT_TYPES[path.extname(filePath).toLowerCase()] || "application/octet-stream";
}

function safeJoinStatic(root, requestPath) {
  const decoded = decodeURIComponent(requestPath);
  const relative = decoded.replace(/^\/+/, "");
  const fullPath = path.resolve(root, relative);
  const rootPath = path.resolve(root);
  if (fullPath !== rootPath && !fullPath.startsWith(`${rootPath}${path.sep}`)) {
    return null;
  }
  return fullPath;
}

async function serveStaticFile(req, res, filePath) {
  try {
    const body = await readFile(filePath);
    respondBuffer(
      res,
      200,
      body,
      {
        "content-type": contentTypeForFile(filePath),
        "cache-control": filePath.includes(`${path.sep}assets${path.sep}`)
          ? "public, max-age=31536000, immutable"
          : "no-cache",
      },
      req?.headers?.["accept-encoding"] || "",
    );
    return true;
  } catch {
    return false;
  }
}

async function serveManagementUi(req, res, requestPathname) {
  const uiPrefix = `${UI_PATH}/`;
  if (requestPathname === UI_PATH || requestPathname === `${UI_PATH}/`) {
    return serveStaticFile(req, res, path.join(UI_STATIC_ROOT, "index.html"));
  }

  if (!requestPathname.startsWith(uiPrefix)) {
    return false;
  }

  const staticPath = safeJoinStatic(UI_STATIC_ROOT, requestPathname.slice(uiPrefix.length));
  if (!staticPath) {
    jsonResponse(req, res, 403, {
      error: {
        message: "invalid static path",
        code: "invalid_static_path",
      },
    });
    return true;
  }

  if (await serveStaticFile(req, res, staticPath)) {
    return true;
  }

  return serveStaticFile(req, res, path.join(UI_STATIC_ROOT, "index.html"));
}

async function serveManagementUiWithOptionalCookie(req, res, requestPathname, cookieHeaders) {
  const uiPrefix = `${UI_PATH}/`;
  if (requestPathname === UI_PATH || requestPathname === `${UI_PATH}/`) {
    try {
      const body = await readFile(path.join(UI_STATIC_ROOT, "index.html"));
      respondBuffer(
        res,
        200,
        body,
        {
          "content-type": "text/html; charset=utf-8",
          "cache-control": "no-cache",
          ...(cookieHeaders?.length ? { "set-cookie": cookieHeaders } : {}),
        },
        req?.headers?.["accept-encoding"] || "",
      );
      return true;
    } catch {
      return false;
    }
  }
  if (!requestPathname.startsWith(uiPrefix)) {
    return false;
  }
  return serveManagementUi(req, res, requestPathname);
}

function renderManagementAccessPage(requestPathname, errorMessage = "") {
  const escapedAction = `${requestPathname || UI_PATH}`.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
  const escapedError = `${errorMessage || ""}`
    .replace(/&/g, "&amp;")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;");
  return `<!doctype html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Codex Retry Gateway</title>
  <style>
    body { margin: 0; font-family: ui-sans-serif, system-ui, sans-serif; background: #0b1020; color: #eef2ff; }
    main { min-height: 100vh; display: grid; place-items: center; padding: 24px; }
    form { width: min(420px, 100%); background: #121933; border: 1px solid #26304f; padding: 24px; border-radius: 8px; }
    h1 { margin: 0 0 8px; font-size: 20px; }
    p { margin: 0 0 16px; color: #aab4d6; line-height: 1.5; }
    label { display: block; margin-bottom: 8px; font-size: 14px; color: #cbd5f5; }
    input { width: 100%; box-sizing: border-box; padding: 12px; border-radius: 6px; border: 1px solid #33406a; background: #0f1630; color: #eef2ff; }
    button { margin-top: 16px; width: 100%; padding: 12px; border: 0; border-radius: 6px; background: #7c9cff; color: #09101f; font-weight: 600; cursor: pointer; }
    .error { min-height: 20px; margin-top: 12px; color: #fca5a5; font-size: 14px; }
  </style>
</head>
<body>
  <main>
    <form method="get" action="${escapedAction}">
      <h1>Codex Retry Gateway</h1>
      <p>此页面已启用访问 key。输入后会在当前浏览器保存后台访问状态。</p>
      <label for="key">Access key</label>
      <input id="key" name="key" type="password" autofocus autocomplete="current-password">
      <button type="submit">进入后台</button>
      <div class="error">${escapedError}</div>
    </form>
  </main>
</body>
</html>`;
}

function buildEditableConfig(currentConfig, payload) {
  const nextReasoningMatchMode = normalizeReasoningMatchMode(
    payload.reasoning_match_mode === undefined
      ? currentConfig.reasoning_match_mode
      : payload.reasoning_match_mode,
  );
  const nextReasoning = normalizeReasoningEquals(
    payload.reasoning_equals === undefined ? currentConfig.reasoning_equals : payload.reasoning_equals,
    currentConfig.reasoning_equals,
  );
  const nextRetryableStatusCodes = normalizeIntegerList(
    payload.retryable_status_codes,
    currentConfig.retryable_status_codes,
  );
  const nextRetryableErrorMessages = normalizePhraseList(
    payload.retryable_error_messages,
    currentConfig.retryable_error_messages,
  );
  const nextEndpoints = normalizeStringList(payload.endpoints, currentConfig.endpoints).map(normalizePath);
  const nextUpstreamFetchRetryAttempts =
    payload.upstream_fetch_retry_attempts === undefined
      ? normalizePositiveInteger(
          currentConfig.upstream_fetch_retry_attempts,
          DEFAULT_CONFIG.upstream_fetch_retry_attempts,
        )
      : normalizePositiveInteger(
          payload.upstream_fetch_retry_attempts,
          DEFAULT_CONFIG.upstream_fetch_retry_attempts,
        );
  const nextUpstreamFetchRetryBackoffMs =
    payload.upstream_fetch_retry_backoff_ms === undefined
      ? normalizeNonNegativeInteger(
          currentConfig.upstream_fetch_retry_backoff_ms,
          DEFAULT_CONFIG.upstream_fetch_retry_backoff_ms,
        )
      : normalizeNonNegativeInteger(
          payload.upstream_fetch_retry_backoff_ms,
          DEFAULT_CONFIG.upstream_fetch_retry_backoff_ms,
        );
  const nextStatusCode =
    payload.non_stream_status_code === undefined
      ? currentConfig.non_stream_status_code
      : Number.parseInt(`${payload.non_stream_status_code}`, 10);

  if (nextRetryableStatusCodes.length === 0) {
    throw new Error("retryable_status_codes 不能为空");
  }
  if (nextRetryableErrorMessages.length === 0) {
    throw new Error("retryable_error_messages 不能为空");
  }
  if (nextEndpoints.length === 0) {
    throw new Error("endpoints 不能为空");
  }
  if (nextUpstreamFetchRetryAttempts < 1) {
    throw new Error("upstream_fetch_retry_attempts 必须是正整数");
  }
  if (nextUpstreamFetchRetryBackoffMs < 0) {
    throw new Error("upstream_fetch_retry_backoff_ms 不能为负数");
  }
  if (!Number.isInteger(nextStatusCode) || nextStatusCode < 100 || nextStatusCode > 599) {
    throw new Error("non_stream_status_code 必须是 100-599 的整数");
  }

  return {
    ...currentConfig,
    reasoning_match_mode: nextReasoningMatchMode,
    reasoning_equals: nextReasoning,
    retryable_status_codes: nextRetryableStatusCodes,
    retryable_error_messages: nextRetryableErrorMessages,
    management_access_key:
      payload.management_access_key === undefined
        ? currentManagementAccessKey(currentConfig)
        : normalizeManagementAccessKey(payload.management_access_key),
    endpoints: nextEndpoints,
    upstream_fetch_retry_attempts: nextUpstreamFetchRetryAttempts,
    upstream_fetch_retry_backoff_ms: nextUpstreamFetchRetryBackoffMs,
    non_stream_status_code: nextStatusCode,
    log_match: payload.log_match === undefined ? currentConfig.log_match : Boolean(payload.log_match),
  };
}

async function handleManagementRequest(runtime, req, res, requestUrl) {
  const pathname = normalizePath(requestUrl.pathname);
  const isManagementPath = pathname === ADMIN_BASE_PATH || pathname.startsWith(`${ADMIN_BASE_PATH}/`);
  const accessEnabled = managementAccessEnabled(runtime.config);
  const accessGranted = hasManagementAccess(req, requestUrl, runtime.config);

  if (pathname === UI_PATH || pathname.startsWith(`${UI_PATH}/`)) {
    if (accessEnabled && !accessGranted) {
      if (
        pathname === UI_PATH ||
        pathname === `${UI_PATH}/` ||
        pathname === `${UI_PATH}/index.html`
      ) {
        const body = Buffer.from(
          renderManagementAccessPage(pathname, requestUrl.searchParams.get("key") ? "access key 不正确" : ""),
          "utf8",
        );
        return respondBuffer(
          res,
          401,
          body,
          {
            "content-type": "text/html; charset=utf-8",
            "cache-control": "no-store",
            "set-cookie": clearManagementAccessCookieHeaders(),
          },
          req?.headers?.["accept-encoding"] || "",
        );
      }
      jsonResponse(req, res, 401, managementUnauthorizedPayload(), {
        "cache-control": "no-store",
        "set-cookie": clearManagementAccessCookieHeaders(),
      });
      return true;
    }

    const cookieHeaders = accessEnabled
      ? buildManagementAccessCookieHeaders(runtime.config, requestManagementAccessKey(req, requestUrl))
      : [];
    if (!(await serveManagementUiWithOptionalCookie(req, res, requestUrl.pathname, cookieHeaders))) {
      jsonResponse(req, res, 503, {
        error: {
          message: "UI assets were not built. Run: npm run build:ui",
          code: "ui_not_built",
        },
      });
    }
    return true;
  }

  if (accessEnabled && !accessGranted && isManagementPath) {
    jsonResponse(req, res, 401, managementUnauthorizedPayload(), {
      "cache-control": "no-store",
      "set-cookie": clearManagementAccessCookieHeaders(),
    });
    return true;
  }

  if (pathname === STATUS_API_PATH && req.method === "GET") {
    const state = await readRuntimeState(runtime);
    jsonResponse(req, res, 200, {
      ok: true,
      listen: `${runtime.config.listen_host}:${runtime.config.listen_port}`,
      config: sanitizeConfigForStatus(runtime.config),
      state,
      paths: {
        config_path: runtime.configPath,
        state_path: runtime.paths.statePath,
        state_root: runtime.paths.stateRoot,
        log_path: runtime.logPath,
        requests_path: runtime.paths.requestsPath,
        thread_rules_path: runtime.paths.threadRulesPath,
        profiles_dir: runtime.paths.profilesDir,
        image_profiles_dir: runtime.paths.imageProfilesDir,
      },
      metrics: buildMetricsSnapshot(runtime.monitor),
    }, accessEnabled && accessGranted ? { "set-cookie": buildManagementAccessCookieHeaders(runtime.config, requestManagementAccessKey(req, requestUrl)) } : {});
    return true;
  }

  if (pathname === LOGS_API_PATH && req.method === "GET") {
    const sinceSeqRaw = requestUrl.searchParams.get("since_seq");
    const limitRaw = requestUrl.searchParams.get("limit");
    const sinceSeq = sinceSeqRaw === null ? null : Number.parseInt(sinceSeqRaw, 10);
    const limit = limitRaw === null ? 500 : Number.parseInt(limitRaw, 10);
    jsonResponse(req, res, 200, {
      ok: true,
      ...await buildPersistentLogsSnapshot(
        runtime,
        Number.isInteger(sinceSeq) ? sinceSeq : null,
        Number.isInteger(limit) ? limit : 500,
      ),
    });
    return true;
  }

  if (pathname === REQUESTS_API_PATH && req.method === "GET") {
    const limitRaw = requestUrl.searchParams.get("limit");
    const offsetRaw = requestUrl.searchParams.get("offset");
    const query = requestUrl.searchParams.get("query") || "";
    const filter = requestUrl.searchParams.get("filter") || "all";
    const limit = limitRaw === null ? 50 : Number.parseInt(limitRaw, 10);
    const offset = offsetRaw === null ? 0 : Number.parseInt(offsetRaw, 10);
    jsonResponse(req, res, 200, {
      ok: true,
      ...await buildPersistentRequestsSnapshot(runtime, {
        limit: Number.isInteger(limit) ? limit : 50,
        offset: Number.isInteger(offset) ? offset : 0,
        query,
        filter,
      }),
    });
    return true;
  }

  if (pathname === THREAD_RULES_API_PATH && req.method === "GET") {
    jsonResponse(req, res, 200, {
      ok: true,
      thread_rules_path: runtime.paths.threadRulesPath,
      rules: listThreadRules(runtime),
    });
    return true;
  }

  if (pathname === THREAD_RULES_API_PATH && req.method === "POST") {
    const body = await readRequestBody(req, runtime.config.request_body_limit_bytes);
    const payload = parseJsonSafely(body);
    if (!payload) {
      jsonResponse(req, res, 400, {
        error: {
          message: "thread rule 保存请求必须是有效 JSON",
          code: "invalid_json",
        },
      });
      return true;
    }

    let savedRule;
    try {
      savedRule = await upsertThreadRule(runtime, payload);
    } catch (error) {
      jsonResponse(req, res, 400, {
        error: {
          message: `${error?.message || error}`,
          code: "invalid_thread_rule",
        },
      });
      return true;
    }
    runtime.logger(
      `[thread-rule] thread_id=${savedRule.thread_id} reasoning_intercept_enabled=${savedRule.reasoning_intercept_enabled}`,
    );
    jsonResponse(req, res, 200, {
      ok: true,
      message: savedRule.reasoning_intercept_enabled ? "thread 已开启 reasoning 拦截" : "thread 已关闭 reasoning 拦截",
      saved_rule: savedRule,
      thread_rules_path: runtime.paths.threadRulesPath,
      rules: listThreadRules(runtime),
    });
    return true;
  }

  if (pathname.startsWith(THREAD_RULE_ITEM_API_PREFIX) && req.method === "DELETE") {
    const rawThreadId = pathname.slice(THREAD_RULE_ITEM_API_PREFIX.length);
    if (!rawThreadId || rawThreadId.includes("/")) {
      jsonResponse(req, res, 400, {
        error: {
          message: "无效的 thread_id",
          code: "invalid_thread_id",
        },
      });
      return true;
    }

    const threadId = decodeURIComponent(rawThreadId);
    let removedRule;
    try {
      removedRule = await deleteThreadRule(runtime, threadId);
    } catch (error) {
      jsonResponse(req, res, 400, {
        error: {
          message: `${error?.message || error}`,
          code: "invalid_thread_rule",
        },
      });
      return true;
    }
    runtime.logger(`[thread-rule] thread_id=${threadId} restored_to_default`);
    jsonResponse(req, res, 200, {
      ok: true,
      message: "thread 已恢复默认拦截策略",
      removed_rule: removedRule,
      thread_rules_path: runtime.paths.threadRulesPath,
      rules: listThreadRules(runtime),
    });
    return true;
  }

  if (pathname === PROFILES_API_PATH && req.method === "GET") {
    jsonResponse(req, res, 200, {
      ok: true,
      profiles_dir: runtime.paths.profilesDir,
      active_profile: runtime.config.profile_name || "default",
      profiles: await listProfiles(runtime),
    });
    return true;
  }

  if (pathname === PROFILES_API_PATH && req.method === "POST") {
    const body = await readRequestBody(req, runtime.config.request_body_limit_bytes);
    const payload = parseJsonSafely(body);
    if (!payload) {
      jsonResponse(req, res, 400, {
        error: {
          message: "profile 保存请求必须是有效 JSON",
          code: "invalid_json",
        },
      });
      return true;
    }

    const result = await writeProfile(runtime, payload);
    let applied = null;
    if (result.name === (runtime.config.profile_name || "default")) {
      applied = await applyProfileConfig(runtime, result.name);
    }
    runtime.logger(`[profile] saved name=${result.name} path=${result.file_path}`);
    jsonResponse(req, res, 200, {
      ok: true,
      message: applied ? "profile 已保存并已热应用" : "profile 已保存",
      saved_profile: result,
      applied_profile: applied,
      profiles_dir: runtime.paths.profilesDir,
      active_profile: runtime.config.profile_name || "default",
      profiles: await listProfiles(runtime),
    });
    return true;
  }

  if (pathname === PROFILE_PROBE_API_PATH && req.method === "POST") {
    const body = await readRequestBody(req, runtime.config.request_body_limit_bytes);
    const payload = parseJsonSafely(body);
    if (!payload) {
      jsonResponse(req, res, 400, {
        error: {
          message: "profile probe 请求必须是有效 JSON",
          code: "invalid_json",
        },
      });
      return true;
    }

    const result = await probeProfile(runtime, payload);
    runtime.logger(
      `[profile-probe] profile=${result.profile} auth=${result.auth_mode}/${result.auth_source} upstream=${result.upstream_base_url}`,
    );
    jsonResponse(req, res, 200, {
      ok: true,
      ...result,
    });
    return true;
  }

  if (pathname === PROFILE_SWITCH_API_PATH && req.method === "POST") {
    const body = await readRequestBody(req, runtime.config.request_body_limit_bytes);
    const payload = parseJsonSafely(body);
    const profileName = `${payload?.profile || ""}`.trim();
    if (!profileName) {
      jsonResponse(req, res, 400, {
        error: {
          message: "缺少 profile",
          code: "profile_required",
        },
      });
      return true;
    }

    const result = await applyProfileConfig(runtime, profileName);
    jsonResponse(req, res, 200, {
      ok: true,
      message: "profile 已热切换，无需重启 gateway",
      ...result,
    });
    return true;
  }

  if (pathname.startsWith(PROFILE_ITEM_API_PREFIX) && req.method === "DELETE") {
    const rawName = pathname.slice(PROFILE_ITEM_API_PREFIX.length);
    if (!rawName || rawName.includes("/")) {
      jsonResponse(req, res, 400, {
        error: {
          message: "无效的 profile 名称",
          code: "invalid_profile_name",
        },
      });
      return true;
    }

    const profileName = decodeURIComponent(rawName);
    const result = await deleteProfile(runtime, profileName);
    runtime.logger(`[profile] deleted name=${result.name} path=${result.file_path}`);
    jsonResponse(req, res, 200, {
      ok: true,
      message: "profile 已删除",
      deleted_profile: result,
      profiles_dir: runtime.paths.profilesDir,
      active_profile: runtime.config.profile_name || "default",
      profiles: await listProfiles(runtime),
    });
    return true;
  }

  if (pathname === IMAGE_PROFILES_API_PATH && req.method === "GET") {
    jsonResponse(req, res, 200, {
      ok: true,
      image_profiles_dir: runtime.paths.imageProfilesDir,
      active_image_profile: runtime.config.image_profile_name || "",
      image_profiles: await listImageProfiles(runtime),
    });
    return true;
  }

  if (pathname === IMAGE_PROFILES_API_PATH && req.method === "POST") {
    const body = await readRequestBody(req, runtime.config.request_body_limit_bytes);
    const payload = parseJsonSafely(body);
    if (!payload) {
      jsonResponse(req, res, 400, {
        error: {
          message: "图片 profile 保存请求必须是有效 JSON",
          code: "invalid_json",
        },
      });
      return true;
    }

    const result = await writeImageProfile(runtime, payload);
    let applied = null;
    if (result.name === `${runtime.config.image_profile_name || ""}`.trim()) {
      applied = await applyImageProfileConfig(runtime, result.name);
    }
    runtime.logger(`[image-profile] saved name=${result.name} path=${result.file_path}`);
    jsonResponse(req, res, 200, {
      ok: true,
      message: applied ? "图片 profile 已保存并已热应用" : "图片 profile 已保存",
      saved_image_profile: result,
      applied_image_profile: applied,
      image_profiles_dir: runtime.paths.imageProfilesDir,
      active_image_profile: runtime.config.image_profile_name || "",
      image_profiles: await listImageProfiles(runtime),
    });
    return true;
  }

  if (pathname === IMAGE_PROFILE_PROBE_API_PATH && req.method === "POST") {
    const body = await readRequestBody(req, runtime.config.request_body_limit_bytes);
    const payload = parseJsonSafely(body);
    if (!payload) {
      jsonResponse(req, res, 400, {
        error: {
          message: "图片 profile probe 请求必须是有效 JSON",
          code: "invalid_json",
        },
      });
      return true;
    }
    const result = await probeImageProfile(runtime, payload);
    runtime.logger(
      `[image-profile-probe] profile=${result.image_profile} auth=${result.auth_mode}/${result.auth_source} upstream=${result.image_base_url}`,
    );
    jsonResponse(req, res, 200, { ok: true, ...result });
    return true;
  }

  if (pathname === IMAGE_PROFILE_SWITCH_API_PATH && req.method === "POST") {
    const body = await readRequestBody(req, runtime.config.request_body_limit_bytes);
    const payload = parseJsonSafely(body);
    const profileName = `${payload?.profile || ""}`.trim();
    if (!profileName) {
      jsonResponse(req, res, 400, {
        error: {
          message: "缺少图片 profile",
          code: "profile_required",
        },
      });
      return true;
    }
    const result = await applyImageProfileConfig(runtime, profileName);
    jsonResponse(req, res, 200, {
      ok: true,
      message: "图片 profile 已热切换，无需重启 gateway",
      ...result,
    });
    return true;
  }

  if (pathname.startsWith(IMAGE_PROFILE_ITEM_API_PREFIX) && req.method === "DELETE") {
    const rawName = pathname.slice(IMAGE_PROFILE_ITEM_API_PREFIX.length);
    if (!rawName || rawName.includes("/")) {
      jsonResponse(req, res, 400, {
        error: {
          message: "无效的图片 profile 名称",
          code: "invalid_profile_name",
        },
      });
      return true;
    }
    const profileName = decodeURIComponent(rawName);
    const result = await deleteImageProfile(runtime, profileName);
    runtime.logger(`[image-profile] deleted name=${result.name} path=${result.file_path}`);
    jsonResponse(req, res, 200, {
      ok: true,
      message: "图片 profile 已删除",
      deleted_image_profile: result,
      image_profiles_dir: runtime.paths.imageProfilesDir,
      active_image_profile: runtime.config.image_profile_name || "",
      image_profiles: await listImageProfiles(runtime),
    });
    return true;
  }

  if (pathname === CONFIG_API_PATH && req.method === "POST") {
    const body = await readRequestBody(req, runtime.config.request_body_limit_bytes);
    const payload = parseJsonSafely(body);
    if (!payload) {
      jsonResponse(req, res, 400, {
        error: {
          message: "配置保存请求必须是有效 JSON",
          code: "invalid_json",
        },
      });
      return true;
    }

    const nextConfig = buildEditableConfig(runtime.config, payload);
    await writeConfig(runtime.configPath, nextConfig);
    runtime.config = nextConfig;
    runtime.logger(
      `[config] updated reasoning_match_mode=${nextConfig.reasoning_match_mode} reasoning_equals=${nextConfig.reasoning_equals.join(",")} retryable_status_codes=${nextConfig.retryable_status_codes.join(",")} endpoints=${nextConfig.endpoints.join(",")}`,
    );
    const state = await readRuntimeState(runtime);
    jsonResponse(req, res, 200, {
      ok: true,
      message: "配置已保存并立即生效",
      config: sanitizeConfigForStatus(runtime.config),
      state,
      paths: {
        config_path: runtime.configPath,
        state_path: runtime.paths.statePath,
        state_root: runtime.paths.stateRoot,
        log_path: runtime.logPath,
        thread_rules_path: runtime.paths.threadRulesPath,
      },
      metrics: buildMetricsSnapshot(runtime.monitor),
    });
    return true;
  }

  if (pathname === RESTORE_API_PATH && req.method === "POST") {
    const state = await readRuntimeState(runtime);
    if (!state) {
      jsonResponse(req, res, 409, {
        error: {
          message: "当前未检测到安装状态，无法恢复 Codex 原设置",
          code: "state_not_found",
        },
      });
      return true;
    }

    await restoreRuntimeState(runtime, state);
    runtime.logger(`[restore] restored via UI state_root=${runtime.paths.stateRoot}`);
    jsonResponse(req, res, 202, {
      ok: true,
      message: "原设置已恢复，gateway 即将关闭",
    });
    res.on("finish", () => {
      const exitTimer = setTimeout(() => {
        if (runtime.server) {
          runtime.server.close(() => {
            process.exit(0);
          });
        } else {
          process.exit(0);
        }

        const hardExitTimer = setTimeout(() => {
          process.exit(0);
        }, 600);
        hardExitTimer.unref();
      }, 120);
      exitTimer.unref();
    });
    return true;
  }

  if (isManagementPath) {
    jsonResponse(req, res, 404, {
      error: {
        message: "管理面路径不存在",
        code: "management_endpoint_not_found",
      },
    });
    return true;
  }

  return false;
}

function buildUpstreamUrl(baseUrl, requestUrl) {
  const upstream = new URL(baseUrl);
  const normalizedBasePath = upstream.pathname.endsWith("/")
    ? upstream.pathname.slice(0, -1)
    : upstream.pathname;
  const incomingPath = requestUrl.pathname;

  let finalPath = incomingPath;
  if (normalizedBasePath && normalizedBasePath !== "/") {
    if (incomingPath.startsWith(`${normalizedBasePath}/`) || incomingPath === normalizedBasePath) {
      finalPath = incomingPath;
    } else if (normalizedBasePath.endsWith("/v1") && incomingPath.startsWith("/v1/")) {
      finalPath = `${normalizedBasePath}${incomingPath.slice(3)}`;
    } else {
      finalPath = `${normalizedBasePath}${incomingPath}`;
    }
  }

  upstream.pathname = finalPath;
  upstream.search = requestUrl.search;
  return upstream.toString();
}

function buildUpstreamSnapshot({ upstreamUrl, upstreamAuth = null, upstreamResponse = null }) {
  const parsedUrl = new URL(upstreamUrl);
  const snapshot = {
    origin: parsedUrl.origin,
    path: parsedUrl.pathname,
    auth_mode: upstreamAuth?.mode || "unknown",
    auth_source: upstreamAuth?.source || "unknown",
    authorization_configured: Boolean(upstreamAuth?.authorization),
  };

  if (upstreamResponse) {
    snapshot.status = upstreamResponse.status;
    snapshot.content_type = upstreamResponse.headers.get("content-type") || "";
  }

  return snapshot;
}

function cloneHeadersForUpstream(headers, upstreamAuth = null) {
  const outgoing = new Headers();
  for (const [key, value] of Object.entries(headers)) {
    if (value === undefined) {
      continue;
    }
    const lowerKey = key.toLowerCase();
    if (
      lowerKey === "host" ||
      lowerKey === "content-length" ||
      lowerKey === "connection" ||
      lowerKey === "transfer-encoding"
    ) {
      continue;
    }
    if (Array.isArray(value)) {
      for (const item of value) {
        outgoing.append(key, item);
      }
    } else {
      outgoing.set(key, value);
    }
  }
  if (upstreamAuth?.authorization) {
    outgoing.set("authorization", upstreamAuth.authorization);
  }
  return outgoing;
}

function copyHeadersToClient(sourceHeaders, target) {
  for (const [key, value] of sourceHeaders.entries()) {
    const lowerKey = key.toLowerCase();
    if (
      lowerKey === "content-length" ||
      lowerKey === "transfer-encoding" ||
      lowerKey === "content-encoding" ||
      lowerKey === "connection"
    ) {
      continue;
    }
    target.setHeader(key, value);
  }
}

function cloneResponseHeaders(sourceHeaders) {
  const headers = new Headers();
  for (const [key, value] of sourceHeaders.entries()) {
    headers.set(key, value);
  }
  return headers;
}

const CAPTURED_STREAM_REPLAY_DELAY_MS = 5;

function cloneBufferList(chunks) {
  if (!Array.isArray(chunks) || chunks.length === 0) {
    return null;
  }
  return chunks
    .filter((chunk) => chunk && chunk.length > 0)
    .map((chunk) => (Buffer.isBuffer(chunk) ? Buffer.from(chunk) : Buffer.from(chunk)));
}

async function writeBufferedStreamChunks(res, chunks) {
  const replayChunks = (chunks || []).filter((chunk) => chunk && chunk.length > 0);
  res.socket?.setNoDelay(true);
  res.flushHeaders?.();

  for (let index = 0; index < replayChunks.length; index += 1) {
    if (res.destroyed || res.writableEnded) {
      break;
    }
    const chunk = replayChunks[index];
    const accepted = res.write(chunk);
    if (!accepted) {
      await new Promise((resolve) => {
        let settled = false;
        const finish = () => {
          if (settled) {
            return;
          }
          settled = true;
          res.off("drain", onDrain);
          res.off("close", onClose);
          res.off("error", onClose);
          resolve();
        };
        const onDrain = () => finish();
        const onClose = () => finish();
        res.once("drain", onDrain);
        res.once("close", onClose);
        res.once("error", onClose);
      });
    }
    if (
      index < replayChunks.length - 1 &&
      !res.destroyed &&
      !res.writableEnded
    ) {
      await sleep(CAPTURED_STREAM_REPLAY_DELAY_MS);
    }
  }
}

async function writeCapturedResponse(res, delivery) {
  if (!delivery) {
    throw new Error("missing captured response delivery");
  }
  copyHeadersToClient(delivery.headers, res);
  res.writeHead(delivery.status_code);
  if (Array.isArray(delivery.stream_chunks) && delivery.stream_chunks.length > 0) {
    await writeBufferedStreamChunks(res, delivery.stream_chunks);
    if (!res.writableEnded) {
      res.end();
    }
    return;
  }
  res.end(delivery.body);
}

function buildCapturedDelivery(statusCode, headers, body, options = {}) {
  const delivery = {
    status_code: statusCode,
    headers: cloneResponseHeaders(headers),
    body: Buffer.isBuffer(body) ? body : Buffer.from(body || ""),
  };
  const streamChunks = cloneBufferList(options.stream_chunks);
  if (streamChunks && streamChunks.length > 0) {
    delivery.stream_chunks = streamChunks;
  }
  return delivery;
}

function createAbortReason(code, message) {
  const error = new Error(message);
  error.name = "AbortError";
  error.code = code;
  return error;
}

function abortReasonCode(value) {
  return value?.reason?.code || value?.code || null;
}

function createLinkedAbortController(signals = []) {
  const controller = new AbortController();
  const cleanups = [];
  const linkSignal = (signal) => {
    if (!signal) {
      return;
    }
    const abort = () => {
      if (!controller.signal.aborted) {
        controller.abort(signal.reason || createAbortReason(REASONING_RETRY_ABORT_CLIENT, "request aborted"));
      }
    };
    if (signal.aborted) {
      abort();
      return;
    }
    signal.addEventListener("abort", abort, { once: true });
    cleanups.push(() => signal.removeEventListener("abort", abort));
  };
  for (const signal of signals) {
    linkSignal(signal);
    if (controller.signal.aborted) {
      break;
    }
  }
  return {
    controller,
    cleanup() {
      for (const cleanup of cleanups) {
        cleanup();
      }
    },
  };
}

function createClientAbortContext(req, res) {
  const controller = new AbortController();
  const abort = () => {
    if (!controller.signal.aborted) {
      controller.abort(
        createAbortReason(REASONING_RETRY_ABORT_CLIENT, "client disconnected before reasoning retry completed"),
      );
    }
  };
  const onAborted = () => abort();
  const onReqClose = () => {
    if (req.destroyed && !res.writableEnded) {
      abort();
    }
  };
  const onResClose = () => {
    if (!res.writableEnded) {
      abort();
    }
  };
  req.on("aborted", onAborted);
  req.on("close", onReqClose);
  res.on("close", onResClose);
  return {
    signal: controller.signal,
    cleanup() {
      req.off("aborted", onAborted);
      req.off("close", onReqClose);
      res.off("close", onResClose);
    },
  };
}

function isResponsesReasoningRetryPath(pathname) {
  return RESPONSES_REASONING_RETRY_PATHS.has(normalizePath(pathname));
}

function isResponsesReasoningRetryEligible(pathname, requestEntry) {
  return isResponsesReasoningRetryPath(pathname) && Boolean(requestEntry?.thread_id) && Boolean(requestEntry?.reasoning_retry_enabled);
}

function reasoningRetryWaveWidth(round) {
  if (round <= 2) {
    return 1;
  }
  if (round <= 4) {
    return 2;
  }
  return 4;
}

async function readRequestBody(req, limitBytes) {
  const chunks = [];
  let total = 0;
  for await (const chunk of req) {
    total += chunk.length;
    if (total > limitBytes) {
      throw new Error(`请求体超过限制: ${limitBytes} bytes`);
    }
    chunks.push(chunk);
  }
  return Buffer.concat(chunks);
}

function parseJsonSafely(buffer) {
  try {
    return JSON.parse(buffer.toString("utf8"));
  } catch {
    return null;
  }
}

function rebuildBufferedResponse(response, bodyBuffer) {
  return new Response(bodyBuffer, {
    status: response.status,
    statusText: response.statusText,
    headers: new Headers(response.headers),
  });
}

function matchPath(config, pathname) {
  return config.endpoints.includes(normalizePath(pathname));
}

function isImageRequestPath(pathname) {
  const normalizedPath = normalizePath(pathname);
  return (
    normalizedPath === "/images" ||
    normalizedPath.startsWith("/images/") ||
    normalizedPath === "/v1/images" ||
    normalizedPath.startsWith("/v1/images/")
  );
}

function normalizeImageRequestUrl(requestUrl) {
  const normalized = new URL(requestUrl.toString());
  if (normalized.pathname === "/images" || normalized.pathname.startsWith("/images/")) {
    normalized.pathname = `/v1${normalized.pathname}`;
  }
  return normalized;
}

function selectUpstreamRoute(config, pathname) {
  if (isImageRequestPath(pathname) && `${config.image_base_url || ""}`.trim()) {
    return {
      kind: "images",
      baseUrl: config.image_base_url,
      authConfig: {
        upstream_auth_mode: config.image_auth_mode,
        upstream_auth_env: config.image_auth_env,
        upstream_auth_file: config.image_auth_file,
        upstream_auth_json_path: config.image_auth_json_path,
        upstream_auth_json_key: config.image_auth_json_key,
      },
    };
  }
  return {
    kind: "default",
    baseUrl: config.upstream_base_url,
    authConfig: config,
  };
}

function reasoningMatchesFormula518nMinus2(reasoning) {
  return Number.isInteger(reasoning) && reasoning >= 516 && (reasoning + 2) % 518 === 0;
}

function reasoningMatchedByConfig(config, reasoning) {
  if (!Number.isInteger(reasoning)) {
    return false;
  }
  if (normalizeReasoningMatchMode(config.reasoning_match_mode) === "manual") {
    return config.reasoning_equals.includes(reasoning);
  }
  return reasoningMatchesFormula518nMinus2(reasoning);
}

function reasoningMatched(runtime, config, requestEntry, reasoning) {
  if (!getThreadReasoningState(runtime, requestEntry?.thread_id).reasoning_intercept_enabled) {
    return false;
  }
  return reasoningMatchedByConfig(config, reasoning);
}

function collectRetryableMessageCandidates(value, state = { seen: new Set(), results: [] }, depth = 0) {
  if (value === null || value === undefined || depth > 5 || state.results.length >= 64) {
    return state.results;
  }

  if (typeof value === "string") {
    const trimmed = value.trim();
    if (trimmed) {
      state.results.push(trimmed);
    }
    return state.results;
  }

  if (typeof value !== "object") {
    return state.results;
  }

  if (state.seen.has(value)) {
    return state.results;
  }
  state.seen.add(value);

  if (Array.isArray(value)) {
    for (const item of value) {
      collectRetryableMessageCandidates(item, state, depth + 1);
    }
    return state.results;
  }

  const preferredKeys = ["message", "error", "detail", "details", "description", "title"];
  for (const key of preferredKeys) {
    if (Object.hasOwn(value, key)) {
      collectRetryableMessageCandidates(value[key], state, depth + 1);
    }
  }
  for (const [key, nested] of Object.entries(value)) {
    if (preferredKeys.includes(key)) {
      continue;
    }
    collectRetryableMessageCandidates(nested, state, depth + 1);
  }

  return state.results;
}

function truncateRetryableMessage(value, maxLength = 280) {
  const text = `${value || ""}`.trim();
  if (!text) {
    return "";
  }
  return text.length > maxLength ? `${text.slice(0, maxLength - 3)}...` : text;
}

const RETRYABLE_OVERLOAD_ERROR_CODES = new Set([
  "server_is_overloaded",
  "slow_down",
]);

function findRetryableOverloadErrorCode(value, state = { seen: new Set() }, depth = 0) {
  if (!value || typeof value !== "object" || depth > 6 || state.seen.has(value)) {
    return null;
  }
  state.seen.add(value);

  if (Array.isArray(value)) {
    for (const item of value) {
      const match = findRetryableOverloadErrorCode(item, state, depth + 1);
      if (match) {
        return match;
      }
    }
    return null;
  }

  const code = typeof value.code === "string" ? value.code.trim().toLowerCase() : "";
  if (RETRYABLE_OVERLOAD_ERROR_CODES.has(code)) {
    return {
      matched_code: code,
      matched_pattern: `error_code:${code}`,
      matched_message: truncateRetryableMessage(
        firstNonEmptyString(value.message, value.detail, value.description, code),
      ),
    };
  }

  for (const nested of Object.values(value)) {
    const match = findRetryableOverloadErrorCode(nested, state, depth + 1);
    if (match) {
      return match;
    }
  }
  return null;
}

function findRetryableUpstreamErrorMatch(config, upstreamStatusCode, parsedBody, bodyText) {
  const retryableMessages = normalizePhraseList(
    config.retryable_error_messages,
    DEFAULT_CONFIG.retryable_error_messages,
  );
  if (retryableMessages.length === 0) {
    return null;
  }

  const retryableStatusCodes = normalizeIntegerList(
    config.retryable_status_codes,
    DEFAULT_CONFIG.retryable_status_codes,
  );
  const statusEligible = isUpstreamErrorStatus(upstreamStatusCode) && (
    retryableStatusCodes.length === 0 ||
    retryableStatusCodes.includes(upstreamStatusCode)
  );
  const failurePayload = isRetryableErrorPayloadShape(parsedBody);
  if (!statusEligible && !failurePayload) {
    return null;
  }

  const overloadCodeMatch = findRetryableOverloadErrorCode(parsedBody);
  if (overloadCodeMatch) {
    return overloadCodeMatch;
  }

  return matchRetryableMessage(config, parsedBody, bodyText);
}

function matchRetryableMessage(config, parsedBody, bodyText) {
  const retryableMessages = normalizePhraseList(
    config.retryable_error_messages,
    DEFAULT_CONFIG.retryable_error_messages,
  );
  if (retryableMessages.length === 0) {
    return null;
  }

  const normalizedPatterns = retryableMessages.map((message) => ({
    original: message,
    normalized: message.toLowerCase(),
  }));
  const candidateMessages = [];

  if (parsedBody) {
    candidateMessages.push(...collectRetryableMessageCandidates(parsedBody));
  }
  const trimmedBodyText = `${bodyText || ""}`.trim();
  if (trimmedBodyText) {
    candidateMessages.push(trimmedBodyText);
  }

  for (const candidate of candidateMessages) {
    const normalizedCandidate = candidate.toLowerCase();
    for (const pattern of normalizedPatterns) {
      if (normalizedCandidate.includes(pattern.normalized)) {
        return {
          matched_pattern: pattern.original,
          matched_message: truncateRetryableMessage(candidate),
        };
      }
    }
  }

  return null;
}

function hasRetryableFailureKeyword(value) {
  const normalized = `${value || ""}`.trim().toLowerCase();
  if (!normalized) {
    return false;
  }
  return (
    normalized.includes("error") ||
    normalized.includes("failed") ||
    normalized.includes("failure") ||
    normalized.includes("cancelled") ||
    normalized.includes("canceled") ||
    normalized.includes("rate_limit") ||
    normalized.includes("overloaded") ||
    normalized.includes("unavailable")
  );
}

function hasRetryableFailureShape(value, depth = 0) {
  if (!value || depth > 4) {
    return false;
  }
  if (Array.isArray(value)) {
    return value.some((item) => hasRetryableFailureShape(item, depth + 1));
  }
  if (typeof value !== "object") {
    return false;
  }
  if (Object.hasOwn(value, "error")) {
    return true;
  }
  if (Number.isInteger(value.status) && value.status >= 400) {
    return true;
  }
  for (const key of ["type", "event", "status", "state", "result", "code"]) {
    if (typeof value[key] === "string" && hasRetryableFailureKeyword(value[key])) {
      return true;
    }
  }
  for (const key of ["response", "data", "meta", "details", "detail"]) {
    if (hasRetryableFailureShape(value[key], depth + 1)) {
      return true;
    }
  }
  return false;
}

function isRetryableErrorPayloadShape(parsedBody, eventName = "") {
  if (hasRetryableFailureKeyword(eventName)) {
    return true;
  }
  if (!parsedBody || typeof parsedBody !== "object" || Array.isArray(parsedBody)) {
    return false;
  }
  return hasRetryableFailureShape(parsedBody);
}

function findRetryableStreamErrorMatch(config, parsedBody, bodyText, eventName = "") {
  if (!isRetryableErrorPayloadShape(parsedBody, eventName)) {
    return null;
  }
  const overloadCodeMatch = findRetryableOverloadErrorCode(parsedBody);
  if (overloadCodeMatch) {
    return overloadCodeMatch;
  }
  return matchRetryableMessage(config, parsedBody, bodyText);
}

function findRetryableStreamTerminationMatch(config, error) {
  const message = `${error?.message || error || ""}`.trim();
  if (!message) {
    return null;
  }
  return matchRetryableMessage(config, null, message);
}

function isExpectedStreamTermination(error) {
  if (!error) {
    return false;
  }
  const message = `${error?.message || ""}`.trim().toLowerCase();
  if (error.name === "AbortError") {
    return true;
  }
  return error instanceof TypeError && (
    message === "terminated" ||
    message.includes("stream disconnected before completion")
  );
}

function isRetryableUpstreamFetchError(error) {
  if (!error) {
    return false;
  }
  return error instanceof TypeError && error.message === "fetch failed";
}

function isUpstreamErrorStatus(statusCode) {
  return Number.isInteger(statusCode) && statusCode >= 400;
}

function computeRetryBackoffMs(config, attempt) {
  const baseDelay = normalizeNonNegativeInteger(
    config?.upstream_fetch_retry_backoff_ms,
    DEFAULT_CONFIG.upstream_fetch_retry_backoff_ms,
  );
  if (baseDelay <= 0 || attempt <= 1) {
    return baseDelay;
  }
  const multiplier = Math.min(attempt - 1, 4);
  return baseDelay * multiplier;
}

async function fetchUpstreamWithRetry(upstreamUrl, init, config, logger, requestContext = {}) {
  const maxAttempts = normalizePositiveInteger(
    config?.upstream_fetch_retry_attempts,
    DEFAULT_CONFIG.upstream_fetch_retry_attempts,
  );
  const method = `${requestContext.method || init?.method || "GET"}`.toUpperCase();
  const pathname = requestContext.pathname || "";

  let lastError = null;
  let lastResponse = null;
  let retryableUpstreamError = null;

  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
    try {
      const response = await fetch(upstreamUrl, init);
      lastResponse = response;

      if (method === "GET") {
        return {
          response,
          attempt_count: attempt,
          retryable_upstream_error: null,
        };
      }

      const contentType = response.headers.get("content-type");
      if (!isJsonContentType(contentType)) {
        return {
          response,
          attempt_count: attempt,
          retryable_upstream_error: null,
        };
      }

      const bodyBuffer = Buffer.from(await response.arrayBuffer());
      const parsed = parseJsonSafely(bodyBuffer);
      const bodyText = bodyBuffer.toString("utf8");
      retryableUpstreamError = findRetryableUpstreamErrorMatch(
        config,
        response.status,
        parsed,
        bodyText,
      );

      if (!retryableUpstreamError) {
        return {
          response: rebuildBufferedResponse(response, bodyBuffer),
          attempt_count: attempt,
          retryable_upstream_error: null,
        };
      }

      if (attempt === maxAttempts) {
        return {
          response: rebuildBufferedResponse(response, bodyBuffer),
          attempt_count: attempt,
          retryable_upstream_error: {
            ...retryableUpstreamError,
            upstream_status_code: response.status,
          },
        };
      }

      const backoffMs = computeRetryBackoffMs(config, attempt);
      logger?.(
        `[retry] upstream retryable error attempt=${attempt} next_attempt=${attempt + 1} status=${response.status} path=${pathname || "-"} reason=${JSON.stringify(retryableUpstreamError.matched_pattern)} backoff_ms=${backoffMs}`,
      );
      if (backoffMs > 0) {
        await sleep(backoffMs);
      }
    } catch (error) {
      lastError = error;
      if (error && typeof error === "object") {
        error.gatewayAttemptCount = attempt;
      }
      if (!isRetryableUpstreamFetchError(error) || attempt === maxAttempts) {
        break;
      }
      const backoffMs = computeRetryBackoffMs(config, attempt);
      logger?.(
        `[retry] upstream fetch failed attempt=${attempt} next_attempt=${attempt + 1} method=${method} path=${pathname || "-"} url=${upstreamUrl} backoff_ms=${backoffMs}`,
      );
      if (backoffMs > 0) {
        await sleep(backoffMs);
      }
    }
  }

  if (lastError) {
    throw lastError;
  }

  return {
    response: lastResponse,
    attempt_count: maxAttempts,
    retryable_upstream_error: retryableUpstreamError,
  };
}

function inspectSseChunk(state, chunk, config) {
  const decoded = state.decoder.decode(chunk, { stream: true });
  state.buffer += decoded;
  const blocks = state.buffer.split(/\r?\n\r?\n/);
  state.buffer = blocks.pop() ?? "";
  return inspectSseBlocks(blocks, config);
}

async function handleNonStreaming({
  runtime,
  config,
  logger,
  monitor,
  pathname,
  upstreamResponse,
  res,
  requestEntry,
  terminalRetryableUpstreamError = null,
  captureOnly = false,
  persistEntry = true,
}) {
  markRequestEntryFirstResponse(runtime, requestEntry, { persistEntry });
  const bodyBuffer = Buffer.from(await upstreamResponse.arrayBuffer());
  const bodyText = bodyBuffer.toString("utf8");
  const parsed = isJsonContentType(upstreamResponse.headers.get("content-type"))
    ? parseJsonSafely(bodyBuffer)
    : null;
  const reasoning = parsed ? extractReasoningTokens(parsed) : null;
  const usage = parsed ? normalizeUsageSnapshot(parsed) : null;
  const responseId = parsed ? extractNonStreamingResponseId(parsed) : null;
  const threadId = firstNonEmptyString(
    requestEntry.thread_id,
    parsed ? extractResponseThreadId(parsed) : null,
  );
  const retryableUpstreamError = terminalRetryableUpstreamError || findRetryableUpstreamErrorMatch(
    config,
    upstreamResponse.status,
    parsed,
    bodyText,
  );
  requestEntry.response_id = responseId || requestEntry.response_id || null;
  requestEntry.thread_id = threadId || requestEntry.thread_id || null;
  applyThreadReasoningState(runtime, requestEntry, pathname);
  const matched = reasoningMatched(runtime, config, requestEntry, reasoning);

  recordInspectedResponse(monitor, reasoning, matched || Boolean(retryableUpstreamError));

  if (matched) {
    if (config.log_match) {
      logger(
        `[match] non-stream path=${pathname} reasoning_tokens=${reasoning} action=status_${config.non_stream_status_code}`,
      );
    }
    if (!captureOnly) {
      const blockedBody = buildBlockedBody(pathname, reasoning, config.non_stream_status_code);
      res.writeHead(config.non_stream_status_code, {
        "content-type": "application/json; charset=utf-8",
        "x-codex-retry-gateway-reason": "reasoning-guard-triggered",
      });
      res.end(blockedBody);
    }
    return {
      inspected: true,
      matched,
      match_reason: "reasoning_guard",
      status_code: config.non_stream_status_code,
      upstream_status_code: upstreamResponse.status,
      reasoning_tokens: reasoning,
      usage,
      response_id: requestEntry.response_id,
      thread_id: requestEntry.thread_id,
    };
  }

  if (retryableUpstreamError) {
    if (config.log_match) {
      logger(
        `[match] non-stream path=${pathname} upstream_status=${upstreamResponse.status} retryable_error=${JSON.stringify(retryableUpstreamError.matched_pattern)} action=status_${config.non_stream_status_code}`,
      );
    }
    const blockedBody = buildRetryableUpstreamErrorBody(
      pathname,
      upstreamResponse.status,
      retryableUpstreamError.matched_message || retryableUpstreamError.matched_pattern,
      config.non_stream_status_code,
    );
    if (!captureOnly) {
      res.writeHead(config.non_stream_status_code, {
        "content-type": "application/json; charset=utf-8",
        "x-codex-retry-gateway-reason": "upstream-error-retry-triggered",
      });
      res.end(blockedBody);
    }
    return {
      inspected: true,
      matched: true,
      status_code: config.non_stream_status_code,
      upstream_status_code: upstreamResponse.status,
      reasoning_tokens: reasoning,
      usage,
      error: `retryable upstream error: ${retryableUpstreamError.matched_pattern}`,
      match_reason: "retryable_upstream_error",
      response_id: requestEntry.response_id,
      thread_id: requestEntry.thread_id,
      delivery: captureOnly
        ? buildCapturedDelivery(
          config.non_stream_status_code,
          new Headers({
            "content-type": "application/json; charset=utf-8",
            "x-codex-retry-gateway-reason": "upstream-error-retry-triggered",
          }),
          blockedBody,
        )
        : null,
    };
  }

  if (!captureOnly) {
    copyHeadersToClient(upstreamResponse.headers, res);
    res.writeHead(upstreamResponse.status);
    res.end(bodyBuffer);
  }
  return {
    inspected: true,
    matched,
    status_code: upstreamResponse.status,
    upstream_status_code: upstreamResponse.status,
    reasoning_tokens: reasoning,
    usage,
    response_id: requestEntry.response_id,
    thread_id: requestEntry.thread_id,
    delivery: captureOnly
      ? buildCapturedDelivery(upstreamResponse.status, upstreamResponse.headers, bodyBuffer)
      : null,
  };
}

async function handleStreaming({
  runtime,
  config,
  logger,
  monitor,
  pathname,
  upstreamResponse,
  res,
  abortController,
  requestEntry,
  requestAbortSignal = null,
  captureOnly = false,
  persistEntry = true,
}) {
  const strict502Mode = captureOnly || config.stream_action !== "disconnect";
  const reader = upstreamResponse.body.getReader();
  const sseState = {
    decoder: new TextDecoder("utf8"),
    buffer: "",
  };
  const codexResponsesSseState = isResponsesReasoningRetryPath(pathname) && isSseContentType(
    upstreamResponse.headers.get("content-type"),
  )
    ? createResponsesCodexSseState()
    : null;

  let wroteAnyChunk = false;
  let observedReasoning = null;
  let observedUsage = null;
  const bufferedChunks = [];

  if (!strict502Mode && !captureOnly) {
    copyHeadersToClient(upstreamResponse.headers, res);
    res.writeHead(upstreamResponse.status);
  }

  while (true) {
    let readResult;
    try {
      readResult = await reader.read();
    } catch (error) {
      if (requestAbortSignal?.aborted) {
        const abortCode = abortReasonCode(requestAbortSignal);
        if (abortCode === REASONING_RETRY_ABORT_WINNER) {
          return {
            cancelled: true,
            cancel_reason: abortCode,
            response_id: requestEntry.response_id,
            thread_id: requestEntry.thread_id,
            response_bytes_received: requestEntry.response_bytes_received,
            stream_chunk_count: requestEntry.stream_chunk_count,
          };
        }
        throw requestAbortSignal.reason || error;
      }
      if (isExpectedStreamTermination(error)) {
        const retryableTerminationError = findRetryableStreamTerminationMatch(config, error);
        if (retryableTerminationError) {
          return {
            inspected: true,
            matched: true,
            retry_requested: strict502Mode || !wroteAnyChunk,
            retryable_upstream_error: retryableTerminationError,
            upstream_status_code: upstreamResponse.status,
            reasoning_tokens: observedReasoning,
            usage: observedUsage,
            error: `retryable upstream error: ${retryableTerminationError.matched_pattern}`,
            match_reason: "retryable_upstream_error",
            response_id: requestEntry.response_id,
            thread_id: requestEntry.thread_id,
            response_bytes_received: requestEntry.response_bytes_received,
            stream_chunk_count: requestEntry.stream_chunk_count,
          };
        }
        recordInspectedResponse(monitor, observedReasoning, false);
        if (persistEntry) {
          persistStreamingProgress(runtime, requestEntry, { force: true }, new Date());
        }
        if (strict502Mode) {
          logger?.(`[stream] upstream terminated before completion path=${pathname} action=status_502`);
          const gatewayErrorBody = buildGatewayErrorBody("upstream stream terminated before completion");
          if (!captureOnly) {
            res.writeHead(502, { "content-type": "application/json; charset=utf-8" });
            res.end(gatewayErrorBody);
          }
          return {
            inspected: true,
            matched: false,
            status_code: 502,
            upstream_status_code: upstreamResponse.status,
            reasoning_tokens: observedReasoning,
            usage: observedUsage,
            error: "upstream stream terminated before completion",
            response_id: requestEntry.response_id,
            thread_id: requestEntry.thread_id,
            response_bytes_received: requestEntry.response_bytes_received,
            stream_chunk_count: requestEntry.stream_chunk_count,
            delivery: captureOnly
              ? buildCapturedDelivery(
                502,
                new Headers({ "content-type": "application/json; charset=utf-8" }),
                gatewayErrorBody,
              )
              : null,
          };
        } else {
          if (!captureOnly) {
            res.end();
          }
          return {
            inspected: true,
            matched: false,
            status_code: upstreamResponse.status,
            upstream_status_code: upstreamResponse.status,
            reasoning_tokens: observedReasoning,
            usage: observedUsage,
            error: "upstream stream terminated before completion",
            response_id: requestEntry.response_id,
            thread_id: requestEntry.thread_id,
            response_bytes_received: requestEntry.response_bytes_received,
            stream_chunk_count: requestEntry.stream_chunk_count,
          };
        }
      }
      throw error;
    }

    const { done, value } = readResult;
    if (done) {
      const finalInspection = flushSseInspectionRemainder(sseState, config);
      const finalCodexChunks = codexResponsesSseState
        ? flushResponsesSseForCodex(
          codexResponsesSseState,
          requestEntry.response_id || null,
          observedUsage,
        )
        : [];
      if (Number.isInteger(finalInspection.reasoning)) {
        observedReasoning = finalInspection.reasoning;
      }
      observedUsage = mergeUsageSnapshots(observedUsage, finalInspection.usage);
      if (finalInspection.response_id) {
        requestEntry.response_id = finalInspection.response_id;
      }
      if (finalInspection.thread_id) {
        requestEntry.thread_id = finalInspection.thread_id;
      }
      applyThreadReasoningState(runtime, requestEntry, pathname);
      if (codexResponsesSseState?.response_id && !requestEntry.response_id) {
        requestEntry.response_id = codexResponsesSseState.response_id;
      }
      observedUsage = mergeUsageSnapshots(observedUsage, codexResponsesSseState?.usage || null);
      if (finalInspection.retryable_upstream_error) {
        return {
          inspected: true,
          matched: true,
          retry_requested: strict502Mode || !wroteAnyChunk,
          retryable_upstream_error: finalInspection.retryable_upstream_error,
          upstream_status_code: upstreamResponse.status,
          reasoning_tokens: observedReasoning,
          usage: observedUsage,
          error: `retryable upstream error: ${finalInspection.retryable_upstream_error.matched_pattern}`,
          match_reason: "retryable_upstream_error",
          response_id: requestEntry.response_id,
          thread_id: requestEntry.thread_id,
          response_bytes_received: requestEntry.response_bytes_received,
          stream_chunk_count: requestEntry.stream_chunk_count,
        };
      }
      if (reasoningMatched(runtime, config, requestEntry, observedReasoning)) {
        recordInspectedResponse(monitor, observedReasoning, true);
        if (config.log_match) {
          logger(
            `[match] stream path=${pathname} reasoning_tokens=${observedReasoning} action=${config.stream_action}`,
          );
        }
        if (captureOnly) {
          return {
            inspected: true,
            matched: true,
            match_reason: "reasoning_guard",
            status_code: config.non_stream_status_code,
            upstream_status_code: upstreamResponse.status,
            reasoning_tokens: observedReasoning,
            usage: observedUsage,
            response_id: requestEntry.response_id,
            thread_id: requestEntry.thread_id,
            response_bytes_received: requestEntry.response_bytes_received,
            stream_chunk_count: requestEntry.stream_chunk_count,
          };
        }
        if (strict502Mode || !wroteAnyChunk) {
          const blockedBody = buildBlockedBody(pathname, observedReasoning, config.non_stream_status_code);
          res.writeHead(config.non_stream_status_code, {
            "content-type": "application/json; charset=utf-8",
            "x-codex-retry-gateway-reason": "reasoning-guard-triggered",
          });
          res.end(blockedBody);
        } else if (!captureOnly && !res.writableEnded) {
          res.end();
        }
        return {
          inspected: true,
          matched: true,
          match_reason: "reasoning_guard",
          status_code: config.non_stream_status_code,
          upstream_status_code: upstreamResponse.status,
          reasoning_tokens: observedReasoning,
          usage: observedUsage,
          response_id: requestEntry.response_id,
          thread_id: requestEntry.thread_id,
          response_bytes_received: requestEntry.response_bytes_received,
          stream_chunk_count: requestEntry.stream_chunk_count,
        };
      }
      if (finalCodexChunks.length > 0) {
        if (strict502Mode) {
          bufferedChunks.push(...finalCodexChunks);
        } else if (!captureOnly) {
          for (const chunk of finalCodexChunks) {
            wroteAnyChunk = true;
            res.write(chunk);
          }
        }
      }
      recordInspectedResponse(monitor, observedReasoning, false);
      if (persistEntry) {
        persistStreamingProgress(runtime, requestEntry, { force: true }, new Date());
      }
      if (strict502Mode) {
        const replayChunks = cloneBufferList(bufferedChunks) || [];
        const bufferedBody = Buffer.concat(replayChunks);
        if (!captureOnly) {
          copyHeadersToClient(upstreamResponse.headers, res);
          res.writeHead(upstreamResponse.status);
          await writeBufferedStreamChunks(res, replayChunks);
          if (!res.writableEnded) {
            res.end();
          }
        }
        return {
          inspected: true,
          matched: false,
          status_code: upstreamResponse.status,
          upstream_status_code: upstreamResponse.status,
          reasoning_tokens: observedReasoning,
          usage: observedUsage,
          response_id: requestEntry.response_id,
          thread_id: requestEntry.thread_id,
          response_bytes_received: requestEntry.response_bytes_received,
          stream_chunk_count: requestEntry.stream_chunk_count,
          delivery: captureOnly
            ? buildCapturedDelivery(upstreamResponse.status, upstreamResponse.headers, bufferedBody, {
              stream_chunks: replayChunks,
            })
            : null,
        };
      } else {
        if (!captureOnly) {
          res.end();
        }
        return {
          inspected: true,
          matched: false,
          status_code: upstreamResponse.status,
          upstream_status_code: upstreamResponse.status,
          reasoning_tokens: observedReasoning,
          usage: observedUsage,
          response_id: requestEntry.response_id,
          thread_id: requestEntry.thread_id,
          response_bytes_received: requestEntry.response_bytes_received,
          stream_chunk_count: requestEntry.stream_chunk_count,
        };
      }
    }

    const chunkBuffer = Buffer.from(value);
    const now = new Date();
    const inspection = inspectSseChunk(sseState, value, config);
    const retryableUpstreamError = inspection.retryable_upstream_error;
    if (retryableUpstreamError) {
      abortController.abort();
      reader.cancel().catch(() => {});
      return {
        inspected: true,
        matched: true,
        retry_requested: strict502Mode || !wroteAnyChunk,
        retryable_upstream_error: retryableUpstreamError,
        upstream_status_code: upstreamResponse.status,
        reasoning_tokens: observedReasoning,
        usage: observedUsage,
        error: `retryable upstream error: ${retryableUpstreamError.matched_pattern}`,
        match_reason: "retryable_upstream_error",
        response_id: requestEntry.response_id,
        thread_id: requestEntry.thread_id,
        response_bytes_received: requestEntry.response_bytes_received,
        stream_chunk_count: requestEntry.stream_chunk_count,
      };
    }

    markRequestEntryFirstResponse(runtime, requestEntry, { persistEntry, at: now });
    const reasoning = inspection.reasoning;
    const usageUpdated = Boolean(inspection.usage);
    observedUsage = mergeUsageSnapshots(observedUsage, inspection.usage);
    if (Number.isInteger(reasoning)) {
      observedReasoning = reasoning;
    }
    if (inspection.response_id) {
      requestEntry.response_id = inspection.response_id;
    }
    if (inspection.thread_id) {
      requestEntry.thread_id = inspection.thread_id;
    }
    applyThreadReasoningState(runtime, requestEntry, pathname);
    updateStreamingProgress(requestEntry, {
      chunkBytes: chunkBuffer.length,
      usage: inspection.usage,
      reasoning,
      at: now,
    });
    if (persistEntry) {
      persistStreamingProgress(
        runtime,
        requestEntry,
        { usageUpdated, force: requestEntry.stream_chunk_count === 1 },
        now,
      );
    }
    if (reasoningMatched(runtime, config, requestEntry, reasoning)) {
      recordInspectedResponse(monitor, reasoning, true);
      if (config.log_match) {
        logger(
          `[match] stream path=${pathname} reasoning_tokens=${reasoning} action=${config.stream_action}`,
        );
      }

      if (captureOnly) {
        abortController.abort(createAbortReason(REASONING_RETRY_ABORT_WINNER, "reasoning retry wave advanced"));
        reader.cancel().catch(() => {});
      } else if (strict502Mode || !wroteAnyChunk) {
        abortController.abort();
        reader.cancel().catch(() => {});
        const blockedBody = buildBlockedBody(pathname, reasoning, config.non_stream_status_code);
        res.writeHead(config.non_stream_status_code, {
          "content-type": "application/json; charset=utf-8",
          "x-codex-retry-gateway-reason": "reasoning-guard-triggered",
        });
        res.end(blockedBody);
      } else {
        abortController.abort();
        reader.cancel().catch(() => {});
        res.socket?.destroy();
      }
      return {
        inspected: true,
        matched: true,
        match_reason: "reasoning_guard",
        status_code: config.non_stream_status_code,
        upstream_status_code: upstreamResponse.status,
        reasoning_tokens: reasoning,
        usage: observedUsage,
        response_id: requestEntry.response_id,
        thread_id: requestEntry.thread_id,
        response_bytes_received: requestEntry.response_bytes_received,
        stream_chunk_count: requestEntry.stream_chunk_count,
      };
    }

    const outputChunks = codexResponsesSseState
      ? drainResponsesSseForCodex(
        codexResponsesSseState,
        value,
        requestEntry.response_id || null,
      )
      : [chunkBuffer];

    if (strict502Mode) {
      bufferedChunks.push(...outputChunks);
    } else {
      if (!captureOnly) {
        for (const outputChunk of outputChunks) {
          if (!outputChunk || outputChunk.length === 0) {
            continue;
          }
          wroteAnyChunk = true;
          res.write(outputChunk);
        }
      }
    }
  }
}

function buildAttemptRequestEntry(baseEntry) {
  return {
    ...baseEntry,
    lifecycle_state: "sent",
    first_response_at: null,
    first_response_delay_ms: null,
    last_activity_at: null,
    finished_at: null,
    duration_ms: null,
    response_bytes_received: 0,
    response_stream: false,
    stream_chunk_count: 0,
    usage_last_updated_at: null,
    upstream_attempt_count: 0,
    inspected: false,
    matched: false,
    status_code: null,
    upstream_status_code: null,
    reasoning_tokens: null,
    usage: null,
    error: null,
    _started_ms: Date.now(),
  };
}

function classifyGatewayQueryResult(result) {
  if (result?.cancelled) {
    return "cancelled";
  }
  if (result?.match_reason === "reasoning_guard") {
    return "reasoning_retry";
  }
  if (
    Number.isInteger(result?.status_code) &&
    result.status_code >= 200 &&
    result.status_code < 400 &&
    !result?.error
  ) {
    return "success";
  }
  return "fatal";
}

async function executeGatewayQuery({
  runtime,
  config,
  logger,
  monitor,
  pathname,
  req,
  res,
  requestBody,
  requestIsStream,
  upstreamUrl,
  upstreamAuth,
  requestEntry,
  captureOnly = false,
  persistEntry = true,
  externalAbortSignals = [],
}) {
  const maxUpstreamAttempts = normalizePositiveInteger(
    config.upstream_fetch_retry_attempts,
    DEFAULT_CONFIG.upstream_fetch_retry_attempts,
  );
  const shouldInspect = matchPath(config, pathname);
  let totalUpstreamAttempts = 0;
  const queryAbortLink = createLinkedAbortController(externalAbortSignals);

  try {
    while (totalUpstreamAttempts < maxUpstreamAttempts) {
      if (queryAbortLink.controller.signal.aborted) {
        throw queryAbortLink.controller.signal.reason || createAbortReason(
          REASONING_RETRY_ABORT_CLIENT,
          "request aborted",
        );
      }

      const upstreamAbortLink = createLinkedAbortController([queryAbortLink.controller.signal]);
      try {
        const {
          response: upstreamResponse,
          attempt_count: upstreamAttemptCount,
          retryable_upstream_error: terminalRetryableUpstreamError,
        } = await fetchUpstreamWithRetry(upstreamUrl, {
          method: req.method,
          headers: cloneHeadersForUpstream(req.headers, upstreamAuth),
          body: requestBody.length > 0 ? requestBody : undefined,
          signal: upstreamAbortLink.controller.signal,
        }, {
          ...config,
          upstream_fetch_retry_attempts: Math.max(1, maxUpstreamAttempts - totalUpstreamAttempts),
        }, logger, { method: req.method, pathname });

        totalUpstreamAttempts += upstreamAttemptCount;
        requestEntry.upstream_attempt_count = totalUpstreamAttempts;

        const responseContentType = upstreamResponse.headers.get("content-type");
        const responseIsStream = isSseContentType(responseContentType) || (
          requestIsStream &&
          !isJsonContentType(responseContentType) &&
          !isUpstreamErrorStatus(upstreamResponse.status)
        );
        requestEntry.response_stream = responseIsStream;
        requestEntry.inspected = shouldInspect;
        requestEntry.upstream_status_code = upstreamResponse.status;
        const upstreamRoute = requestEntry.upstream?.route || "default";
        requestEntry.upstream = {
          ...buildUpstreamSnapshot({ upstreamUrl, upstreamAuth, upstreamResponse }),
          route: upstreamRoute,
        };
        if (persistEntry) {
          upsertRequestEntry(runtime, requestEntry);
        }
        if (isUpstreamErrorStatus(upstreamResponse.status)) {
          logger?.(
            `[upstream] status=${upstreamResponse.status} profile=${config.profile_name || "default"} path=${requestEntry.upstream.path} auth=${requestEntry.upstream.auth_mode}/${requestEntry.upstream.auth_source} content_type=${requestEntry.upstream.content_type || "-"}`,
          );
        }

        if (!shouldInspect) {
          markRequestEntryFirstResponse(runtime, requestEntry, { persistEntry });
          const body = Buffer.from(await upstreamResponse.arrayBuffer());
          requestEntry.response_bytes_received = body.length;
          const parsed = isJsonContentType(responseContentType)
            ? parseJsonSafely(body)
            : null;
          requestEntry.response_id = requestEntry.response_id || (parsed ? extractNonStreamingResponseId(parsed) : null);
          requestEntry.thread_id = requestEntry.thread_id || (parsed ? extractResponseThreadId(parsed) : null);
          if (!captureOnly) {
            copyHeadersToClient(upstreamResponse.headers, res);
            res.writeHead(upstreamResponse.status);
            res.end(body);
          }
          return {
            response_stream: responseIsStream,
            inspected: false,
            matched: false,
            status_code: upstreamResponse.status,
            upstream_status_code: upstreamResponse.status,
            response_id: requestEntry.response_id,
            thread_id: requestEntry.thread_id,
            total_upstream_attempts: totalUpstreamAttempts,
            delivery: captureOnly
              ? buildCapturedDelivery(upstreamResponse.status, upstreamResponse.headers, body)
              : null,
          };
        }

        const result = responseIsStream
          ? await handleStreaming({
            runtime,
            config,
            logger,
            monitor,
            pathname,
            upstreamResponse,
            res,
            abortController: upstreamAbortLink.controller,
            requestEntry,
            requestAbortSignal: queryAbortLink.controller.signal,
            captureOnly,
            persistEntry,
          })
          : await handleNonStreaming({
            runtime,
            config,
            logger,
            monitor,
            pathname,
            upstreamResponse,
            res,
            requestEntry,
            terminalRetryableUpstreamError,
            captureOnly,
            persistEntry,
          });

        if (result.retry_requested) {
          if (totalUpstreamAttempts < maxUpstreamAttempts) {
            const backoffMs = computeRetryBackoffMs(config, totalUpstreamAttempts);
            logger?.(
              `[retry] upstream retryable stream error attempt=${totalUpstreamAttempts} next_attempt=${totalUpstreamAttempts + 1} status=${upstreamResponse.status} path=${pathname || "-"} reason=${JSON.stringify(result.retryable_upstream_error?.matched_pattern)} backoff_ms=${backoffMs}`,
            );
            if (backoffMs > 0) {
              await sleep(backoffMs);
            }
            continue;
          }

          recordInspectedResponse(runtime.monitor, result.reasoning_tokens, true);
          if (config.log_match) {
            logger?.(
              `[match] stream path=${pathname} upstream_status=${upstreamResponse.status} retryable_error=${JSON.stringify(result.retryable_upstream_error?.matched_pattern)} action=status_${config.non_stream_status_code}`,
            );
          }
          const blockedBody = buildRetryableUpstreamErrorBody(
            pathname,
            upstreamResponse.status,
            result.retryable_upstream_error?.matched_message || result.retryable_upstream_error?.matched_pattern,
            config.non_stream_status_code,
          );
          if (!captureOnly) {
            res.writeHead(config.non_stream_status_code, {
              "content-type": "application/json; charset=utf-8",
              "x-codex-retry-gateway-reason": "upstream-error-retry-triggered",
            });
            res.end(blockedBody);
          }
          return {
            response_stream: true,
            ...result,
            matched: true,
            status_code: config.non_stream_status_code,
            upstream_status_code: upstreamResponse.status,
            total_upstream_attempts: totalUpstreamAttempts,
            delivery: captureOnly
              ? buildCapturedDelivery(
                config.non_stream_status_code,
                new Headers({
                  "content-type": "application/json; charset=utf-8",
                  "x-codex-retry-gateway-reason": "upstream-error-retry-triggered",
                }),
                blockedBody,
              )
              : null,
          };
        }

        return {
          response_stream: responseIsStream,
          ...result,
          total_upstream_attempts: totalUpstreamAttempts,
        };
      } finally {
        upstreamAbortLink.cleanup();
      }
    }
  } catch (error) {
    const accumulatedAttempts = Number.isInteger(error?.gatewayAttemptCount)
      ? totalUpstreamAttempts + error.gatewayAttemptCount
      : totalUpstreamAttempts;
    if (error && typeof error === "object") {
      error.gatewayAttemptCount = accumulatedAttempts;
    }
    throw error;
  } finally {
    queryAbortLink.cleanup();
  }

  throw new Error("gateway query exhausted unexpectedly");
}

async function executeCapturedGatewayQuery(args) {
  try {
    const result = await executeGatewayQuery({
      ...args,
      captureOnly: true,
      persistEntry: false,
    });
    return {
      kind: classifyGatewayQueryResult(result),
      result,
      total_upstream_attempts: result.total_upstream_attempts || 0,
    };
  } catch (error) {
    const abortCode = abortReasonCode(error);
    if (abortCode === REASONING_RETRY_ABORT_CLIENT) {
      throw error;
    }
    if (abortCode === REASONING_RETRY_ABORT_WINNER) {
      return {
        kind: "cancelled",
        result: {
          cancelled: true,
          cancel_reason: abortCode,
        },
        total_upstream_attempts: Number.isInteger(error?.gatewayAttemptCount) ? error.gatewayAttemptCount : 0,
      };
    }

    const gatewayErrorBody = buildGatewayErrorBody(`${error?.message || error}`);
    return {
      kind: "fatal",
      result: {
        inspected: false,
        matched: false,
        status_code: 502,
        upstream_status_code: null,
        error: `${error?.message || error}`,
        delivery: buildCapturedDelivery(
          502,
          new Headers({ "content-type": "application/json; charset=utf-8" }),
          gatewayErrorBody,
        ),
      },
      total_upstream_attempts: Number.isInteger(error?.gatewayAttemptCount) ? error.gatewayAttemptCount : 0,
    };
  }
}

function createReasoningRetryExtraState() {
  return {
    inspected_count: 0,
    matched_count: 0,
    usage: null,
    reasoning_counts: {},
  };
}

function accumulateReasoningRetryExtras(state, outcomes, excludedResult = null) {
  for (const outcome of outcomes) {
    if (outcome?.kind === "cancelled") {
      continue;
    }
    const result = outcome?.result;
    if (!result?.inspected || result === excludedResult) {
      continue;
    }
    state.inspected_count += 1;
    if (result.matched) {
      state.matched_count += 1;
    }
    incrementReasoningCount(state.reasoning_counts, result.reasoning_tokens);
    state.usage = sumUsageSnapshots(state.usage, result.usage);
  }
}

function buildReasoningRetryFirstSlots(round, width) {
  return Array.from({ length: width }, (_, index) => ({
    round,
    slot: index + 1,
    first_response_at: null,
    first_response_delay_ms: null,
    outcome: "pending",
  }));
}

function updateReasoningRetryFirstSlot(requestEntry, round, slot, fields = {}) {
  if (requestEntry.reasoning_retry_current_round !== round) {
    return false;
  }
  const currentFirsts = Array.isArray(requestEntry.reasoning_retry_current_firsts)
    ? requestEntry.reasoning_retry_current_firsts
    : [];
  const index = slot - 1;
  if (index < 0 || index >= currentFirsts.length) {
    return false;
  }
  const existing = currentFirsts[index] || { round, slot };
  currentFirsts[index] = {
    ...existing,
    round,
    slot,
    ...fields,
  };
  requestEntry.reasoning_retry_current_firsts = currentFirsts;
  return true;
}

function updateReasoningRetryFirstFromAttempt(requestEntry, outcome) {
  const attemptEntry = outcome?.requestEntry || {};
  const result = outcome?.result || {};
  return updateReasoningRetryFirstSlot(requestEntry, outcome.round, outcome.slot, {
    first_response_at: attemptEntry.first_response_at || null,
    first_response_delay_ms: Number.isInteger(attemptEntry.first_response_delay_ms)
      ? attemptEntry.first_response_delay_ms
      : null,
    outcome: outcome.kind || "unknown",
    status_code: Number.isInteger(result.status_code) ? result.status_code : null,
    upstream_status_code: Number.isInteger(result.upstream_status_code) ? result.upstream_status_code : null,
    reasoning_tokens: Number.isInteger(result.reasoning_tokens) ? result.reasoning_tokens : null,
    matched: Boolean(result.matched),
  });
}

function markReasoningRetryCancelledSlots(requestEntry, round, slots = []) {
  let changed = false;
  for (const slot of slots) {
    changed = updateReasoningRetryFirstSlot(requestEntry, round, slot, { outcome: "cancelled" }) || changed;
  }
  return changed;
}

async function runResponsesReasoningRetry({
  runtime,
  config,
  logger,
  monitor,
  pathname,
  req,
  requestBody,
  requestIsStream,
  upstreamUrl,
  upstreamAuth,
  requestEntry,
  clientAbortSignal,
}) {
  let round = 1;
  let totalUpstreamAttempts = 0;
  const retryExtraState = createReasoningRetryExtraState();

  while (true) {
    if (clientAbortSignal?.aborted) {
      throw clientAbortSignal.reason || createAbortReason(REASONING_RETRY_ABORT_CLIENT, "client disconnected");
    }

    const width = reasoningRetryWaveWidth(round);
    requestEntry.reasoning_retry_round_count = round;
    requestEntry.reasoning_retry_current_round = round;
    requestEntry.reasoning_retry_current_width = width;
    requestEntry.reasoning_retry_current_firsts = buildReasoningRetryFirstSlots(round, width);
    requestEntry.reasoning_retry_query_count += width;
    if (requestEntry.reasoning_retry_enabled) {
      upsertRequestEntry(runtime, requestEntry);
    }
    logger?.(
      `[reasoning-retry] round=${round} width=${width} path=${pathname} thread_id=${requestEntry.thread_id}`,
    );

    const slotControllers = Array.from({ length: width }, () => new AbortController());
    let winner = null;
    const attempts = slotControllers.map((slotController, index) => {
      const slot = index + 1;
      const attemptEntry = buildAttemptRequestEntry(requestEntry);
      attemptEntry._first_response_observer = (firstFields) => {
        if (updateReasoningRetryFirstSlot(requestEntry, round, slot, firstFields)) {
          upsertRequestEntry(runtime, requestEntry);
        }
      };
      const rawPromise = executeCapturedGatewayQuery({
        runtime,
        config,
        logger,
        monitor,
        pathname,
        req,
        requestBody,
        requestIsStream,
        upstreamUrl,
        upstreamAuth,
        requestEntry: attemptEntry,
        externalAbortSignals: [clientAbortSignal, slotController.signal],
      });
      return new Promise((resolve, reject) => {
        let settled = false;
        const finish = (fn, value) => {
          if (settled) {
            return;
          }
          settled = true;
          slotController.signal.removeEventListener("abort", onAbort);
          fn(value);
        };
        const onAbort = () => {
          if (abortReasonCode(slotController.signal) !== REASONING_RETRY_ABORT_WINNER) {
            return;
          }
          finish(resolve, {
            kind: "cancelled",
            result: {
              cancelled: true,
              cancel_reason: REASONING_RETRY_ABORT_WINNER,
            },
            total_upstream_attempts: 0,
            round,
            slot,
            requestEntry: attemptEntry,
          });
        };
        slotController.signal.addEventListener("abort", onAbort, { once: true });
        rawPromise.then(
          (outcome) => {
            const attemptOutcome = {
              ...outcome,
              round,
              slot,
              requestEntry: attemptEntry,
            };
            if (!winner && attemptOutcome.kind === "success") {
              winner = attemptOutcome;
              const cancelledSlots = [];
              slotControllers.forEach((otherController, otherIndex) => {
                const otherSlot = otherIndex + 1;
                if (otherController !== slotController && !otherController.signal.aborted) {
                  cancelledSlots.push(otherSlot);
                  otherController.abort(
                    createAbortReason(REASONING_RETRY_ABORT_WINNER, "reasoning retry winner selected"),
                  );
                }
              });
              if (cancelledSlots.length > 0) {
                markReasoningRetryCancelledSlots(requestEntry, round, cancelledSlots);
                upsertRequestEntry(runtime, requestEntry);
              }
            }
            finish(resolve, attemptOutcome);
          },
          (error) => finish(reject, error),
        );
      });
    });

    const outcomes = await Promise.all(attempts);
    totalUpstreamAttempts += outcomes.reduce((sum, outcome) => {
      return sum + (Number.isInteger(outcome.total_upstream_attempts) ? outcome.total_upstream_attempts : 0);
    }, 0);
    const nonCancelledOutcomes = outcomes.filter((outcome) => outcome.kind !== "cancelled");
    for (const outcome of outcomes) {
      updateReasoningRetryFirstFromAttempt(requestEntry, outcome);
    }
    if (requestEntry.reasoning_retry_enabled) {
      upsertRequestEntry(runtime, requestEntry);
    }

    if (winner) {
      accumulateReasoningRetryExtras(retryExtraState, nonCancelledOutcomes, winner.result);
      requestEntry.reasoning_retry_extra_inspected_count = retryExtraState.inspected_count;
      requestEntry.reasoning_retry_extra_matched_count = retryExtraState.matched_count;
      requestEntry.reasoning_retry_extra_usage = retryExtraState.usage;
      requestEntry.reasoning_retry_extra_reasoning_counts = retryExtraState.reasoning_counts;
      requestEntry.reasoning_retry_winner_round = winner.round;
      requestEntry.reasoning_retry_winner_slot = winner.slot;
      requestEntry.reasoning_retry_stop_reason = "success";
      return {
        ...winner.result,
        response_stream: winner.result.response_stream,
        total_upstream_attempts: totalUpstreamAttempts,
      };
    }

    const allReasoningRetry = nonCancelledOutcomes.length > 0 && nonCancelledOutcomes.every(
      (outcome) => outcome.kind === "reasoning_retry",
    );
    if (allReasoningRetry) {
      accumulateReasoningRetryExtras(retryExtraState, nonCancelledOutcomes);
      round += 1;
      continue;
    }

    const fatalOutcome = nonCancelledOutcomes.find((outcome) => outcome.kind === "fatal");
    if (fatalOutcome) {
      accumulateReasoningRetryExtras(retryExtraState, nonCancelledOutcomes, fatalOutcome.result);
      requestEntry.reasoning_retry_extra_inspected_count = retryExtraState.inspected_count;
      requestEntry.reasoning_retry_extra_matched_count = retryExtraState.matched_count;
      requestEntry.reasoning_retry_extra_usage = retryExtraState.usage;
      requestEntry.reasoning_retry_extra_reasoning_counts = retryExtraState.reasoning_counts;
      requestEntry.reasoning_retry_stop_reason = fatalOutcome.result?.match_reason || "fatal";
      return {
        ...fatalOutcome.result,
        response_stream: fatalOutcome.result.response_stream,
        total_upstream_attempts: totalUpstreamAttempts,
      };
    }

    accumulateReasoningRetryExtras(retryExtraState, nonCancelledOutcomes);
    requestEntry.reasoning_retry_extra_inspected_count = retryExtraState.inspected_count;
    requestEntry.reasoning_retry_extra_matched_count = retryExtraState.matched_count;
    requestEntry.reasoning_retry_extra_usage = retryExtraState.usage;
    requestEntry.reasoning_retry_extra_reasoning_counts = retryExtraState.reasoning_counts;
    requestEntry.reasoning_retry_stop_reason = "exhausted_without_winner";
    return {
      inspected: false,
      matched: false,
      status_code: 502,
      upstream_status_code: null,
      error: "reasoning retry ended without a successful response",
      response_stream: requestIsStream,
      total_upstream_attempts: totalUpstreamAttempts,
      delivery: buildCapturedDelivery(
        502,
        new Headers({ "content-type": "application/json; charset=utf-8" }),
        buildGatewayErrorBody("reasoning retry ended without a successful response"),
      ),
    };
  }
}

async function proxyRequest(runtime, req, res) {
  const { logger } = runtime;
  const config = runtime.config;
  const requestStartedAt = new Date();
  const requestStartedMs = Date.now();
  const incomingUrl = new URL(req.url, `http://${req.headers.host || "127.0.0.1"}`);
  const pathname = normalizePath(incomingUrl.pathname);

  if (pathname === "/favicon.ico") {
    res.writeHead(204, { "cache-control": "public, max-age=86400" });
    res.end();
    return;
  }

  if (pathname === config.health_path) {
    res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
    res.end(
      JSON.stringify({
        ok: true,
        listen: `${config.listen_host}:${config.listen_port}`,
        upstream_base_url: config.upstream_base_url,
        ui_path: UI_PATH,
      }),
    );
    return;
  }

  if (await handleManagementRequest(runtime, req, res, incomingUrl)) {
    return;
  }

  runtime.monitor.total_proxy_request_count += 1;
  const requestSeq = runtime.monitor.next_request_seq;
  runtime.monitor.next_request_seq += 1;
  const requestEntry = buildRequestEntry({
    seq: requestSeq,
    startedAt: requestStartedAt,
    startedMs: requestStartedMs,
    req,
    pathname,
    requestJson: null,
    profileName: config.profile_name || "default",
  });
  upsertRequestEntry(runtime, requestEntry);

  try {
    const rawRequestBody = await readRequestBody(req, config.request_body_limit_bytes);
    const parsedRequestJson = isJsonContentType(req.headers["content-type"])
      ? parseJsonSafely(rawRequestBody)
      : null;
    const { requestJson, remapped, forwardedModel } = remapRequestModel(config, parsedRequestJson);
    const requestBody = remapped ? Buffer.from(JSON.stringify(requestJson)) : rawRequestBody;
    const requestIsStream = Boolean(requestJson?.stream);
    requestEntry.request_body_bytes = rawRequestBody.length;
    requestEntry.request_id = computeRequestId(pathname, rawRequestBody);
    requestEntry.thread_id = firstNonEmptyString(
      extractRequestThreadId(parsedRequestJson),
      extractHeaderThreadId(req.headers),
    );
    requestEntry.model = requestJson?.model || null;
    requestEntry.requested_model = parsedRequestJson?.model || null;
    requestEntry.forwarded_model = forwardedModel || parsedRequestJson?.model || null;
    requestEntry.model = requestEntry.forwarded_model;
    requestEntry.reasoning_effort = extractRequestReasoningEffort(requestJson);
    requestEntry.reasoning_summary = extractRequestReasoningSummary(requestJson);
    requestEntry.request_stream = requestIsStream;
    applyThreadReasoningState(runtime, requestEntry, pathname);
    upsertRequestEntry(runtime, requestEntry);

    const upstreamRoute = selectUpstreamRoute(config, pathname);
    const upstreamRequestUrl = upstreamRoute.kind === "images"
      ? normalizeImageRequestUrl(incomingUrl)
      : incomingUrl;
    const upstreamUrl = buildUpstreamUrl(upstreamRoute.baseUrl, upstreamRequestUrl);
    const upstreamAuth = await resolveUpstreamAuth(upstreamRoute.authConfig, upstreamRoute.kind);
    requestEntry.upstream = {
      ...buildUpstreamSnapshot({ upstreamUrl, upstreamAuth }),
      route: upstreamRoute.kind,
    };
    upsertRequestEntry(runtime, requestEntry);
    if (remapped && requestEntry.requested_model && requestEntry.forwarded_model) {
      logger?.(
        `[model-remap] profile=${config.profile_name || "default"} requested=${requestEntry.requested_model} forwarded=${requestEntry.forwarded_model}`,
      );
    }
    const clientAbortContext = createClientAbortContext(req, res);
    try {
      const result = isResponsesReasoningRetryEligible(pathname, requestEntry)
        ? await runResponsesReasoningRetry({
          runtime,
          config,
          logger,
          monitor: runtime.monitor,
          pathname,
          req,
          requestBody,
          requestIsStream,
          upstreamUrl,
          upstreamAuth,
          requestEntry,
          clientAbortSignal: clientAbortContext.signal,
        })
        : await executeGatewayQuery({
          runtime,
          config,
          logger,
          monitor: runtime.monitor,
          pathname,
          req,
          res,
          requestBody,
          requestIsStream,
          upstreamUrl,
          upstreamAuth,
          requestEntry,
          externalAbortSignals: [clientAbortContext.signal],
        });

      const {
        delivery,
        total_upstream_attempts: observedUpstreamAttempts,
        ...resultFields
      } = result;
      if (delivery && !res.headersSent) {
        await writeCapturedResponse(res, delivery);
      }
      if (Number.isInteger(observedUpstreamAttempts)) {
        requestEntry.upstream_attempt_count = observedUpstreamAttempts;
      }
      if (requestEntry.reasoning_retry_enabled && !requestEntry.reasoning_retry_stop_reason) {
        requestEntry.reasoning_retry_stop_reason = "completed_without_retry";
      }
      recordRequestEntry(
        runtime,
        finalizeRequestEntry(requestEntry, {
          response_stream: Boolean(result.response_stream),
          ...resultFields,
        }),
        config.request_history_limit,
      );
      return;
    } finally {
      clientAbortContext.cleanup();
    }
  } catch (error) {
    if (Number.isInteger(error?.gatewayAttemptCount)) {
      requestEntry.upstream_attempt_count = Math.max(
        requestEntry.upstream_attempt_count || 0,
        error.gatewayAttemptCount,
      );
    }
    recordRequestEntry(
      runtime,
      finalizeRequestEntry(requestEntry, {
        status_code: res.headersSent ? null : 502,
        error: `${error?.message || error}`,
      }),
      config.request_history_limit,
    );
    throw error;
  }
}

async function main() {
  const args = parseArgs(process.argv);
  const configPath = args.config || path.join(__dirname, "config.json");
  const config = await loadConfig(configPath);
  const monitor = createMonitor();
  const paths = buildRuntimePaths(configPath, args.log || null);

  if (args.log) {
    await mkdir(path.dirname(args.log), { recursive: true });
  }
  const logger = createLogger(args.log, createMonitorRecorder(monitor));
  const requestsDb = openRequestsDatabase(paths.requestsDbPath);
  const runtime = {
    config,
    configPath,
    logPath: args.log || null,
    logger,
    monitor,
    paths,
    threadRules: await loadThreadRules(paths.threadRulesPath),
    requestsDb,
    server: null,
  };
  await ensureActiveImageProfile(runtime);
  const importedCount = await importRequestsJsonlToDb(requestsDb, runtime.paths.requestsPath);
  await hydrateMonitorFromDisk(monitor, runtime.paths, config.request_history_limit, requestsDb);
  logger(`[start] hydrated persistent request metrics from db path=${runtime.paths.requestsDbPath}`);
  logger(`[start] requests db ready path=${runtime.paths.requestsDbPath} imported_jsonl_rows=${importedCount}`);
  logger(`[start] thread rules ready path=${runtime.paths.threadRulesPath} count=${runtime.threadRules.size}`);

  const server = http.createServer(async (req, res) => {
    try {
      await proxyRequest(runtime, req, res);
    } catch (error) {
      logger(`[error] ${error?.stack || error}`);
      if (!res.headersSent) {
        res.writeHead(502, { "content-type": "application/json; charset=utf-8" });
        res.end(
          JSON.stringify({
            error: {
              message: `${error?.message || error}`,
              type: "codex_retry_gateway_error",
              code: "gateway_error",
            },
          }),
        );
      } else {
        res.socket?.destroy();
      }
    }
  });
  runtime.server = server;

  let shuttingDown = false;
  const shutdown = (signal) => {
    if (shuttingDown) {
      return;
    }
    shuttingDown = true;
    logger(`[stop] received ${signal}, closing gateway`);
    server.close(() => {
      process.exit(0);
    });
    const hardExitTimer = setTimeout(() => {
      logger("[stop] forced exit after graceful shutdown timeout");
      process.exit(signal === "SIGTERM" || signal === "SIGINT" ? 0 : 1);
    }, 5000);
    hardExitTimer.unref();
  };

  process.on("SIGTERM", () => shutdown("SIGTERM"));
  process.on("SIGINT", () => shutdown("SIGINT"));

  server.listen(runtime.config.listen_port, runtime.config.listen_host, () => {
    updateRuntimeState(runtime, {
      last_started_at: new Date().toISOString(),
      profile_name: runtime.config.profile_name || "default",
      image_profile_name: runtime.config.image_profile_name || "",
      gateway_base_url: `http://${runtime.config.listen_host}:${runtime.config.listen_port}`,
    }).catch((error) => logger(`[state] failed to update runtime state: ${error?.message || error}`));
    logger(
      `[start] codex retry gateway profile=${runtime.config.profile_name || "default"} image_profile=${runtime.config.image_profile_name || "-"} auth=${normalizeAuthMode(runtime.config.upstream_auth_mode)} reasoning_match_mode=${normalizeReasoningMatchMode(runtime.config.reasoning_match_mode)} listening on http://${runtime.config.listen_host}:${runtime.config.listen_port} -> ${runtime.config.upstream_base_url}`,
    );
  });
}

main().catch((error) => {
  process.stderr.write(`${error?.stack || error}\n`);
  process.exit(1);
});