server.js

const express = require("express");
const fs = require("fs");
const path = require("path");
const os = require("os");
const { createProxyMiddleware, fixRequestBody } = require("http-proxy-middleware");

const app = express();
const PORT = process.env.PORT ? Number(process.env.PORT) : 3777;

// Paths
const CODEX_DIR = path.join(os.homedir(), ".codex");
const CONFIG_PATH = process.env.CONFIG_PATH || path.join(CODEX_DIR, "config.toml");
const MODELS_CACHE_PATH = process.env.MODELS_CACHE_PATH || path.join(CODEX_DIR, "models_cache.json");
const BACKUP_DIR = path.join(CODEX_DIR, "Backup");
const PROVIDERS_PATH = process.env.PROVIDERS_PATH || path.join(__dirname, "providers.json");
const AUTH_PATH = process.env.AUTH_PATH || path.join(CODEX_DIR, "auth.json");
// Preserved ChatGPT OAuth credentials. Native GPT passthrough needs Codex in
// apikey mode (so custom providers route through the proxy), but that mode
// hides the ChatGPT login — so before switching we stash the OAuth tokens here
// and the proxy uses them to reach chatgpt.com. Gitignored (contains tokens).
const AUTH_CHATGPT_PATH = process.env.AUTH_CHATGPT_PATH || path.join(__dirname, "auth.chatgpt.json");
// Our merged model catalog. Codex reads this file via the `model_catalog_json`
// config key, which is how the custom models appear in the native picker
// (same mechanism codex-router uses). It is derived data — regenerated from
// the native cache + providers — so it is gitignored.
const MERGED_CATALOG_PATH = process.env.MERGED_CATALOG_PATH || path.join(__dirname, "merged-models.json");
const NATIVE_ALIASES_PATH = process.env.NATIVE_ALIASES_PATH || path.join(__dirname, "native-aliases.json");
const MANAGED_START = "# BEGIN codex-switcher-managed";
const MANAGED_END = "# END codex-switcher-managed";
const MANAGED_PROVIDER_START = "# BEGIN codex-switcher-provider-managed";
const MANAGED_PROVIDER_END = "# END codex-switcher-provider-managed";

// Desktop builds often hide namespaced external slugs in the picker. Publish
// external models under native-looking slots and keep a private alias map for
// routing the selected slot back to provider/model.
function readNativeAliases() {
  try {
    if (!fs.existsSync(NATIVE_ALIASES_PATH)) return {};
    const parsed = JSON.parse(fs.readFileSync(NATIVE_ALIASES_PATH, "utf-8"));
    return parsed && parsed.aliases && typeof parsed.aliases === "object" ? parsed.aliases : {};
  } catch { return {}; }
}

function writeNativeAliases(aliases) {
  fs.writeFileSync(NATIVE_ALIASES_PATH, JSON.stringify({ version: 1, aliases }, null, 2), "utf-8");
}

app.use(express.json({ limit: '50mb' }));
app.use(express.urlencoded({ limit: '50mb', extended: true }));
app.use(express.static(path.join(__dirname, "public")));

// ── File logger ────────────────────────────────────────────────────────────
// Mirrors console output to logs/proxy.log so the request/stream flow can be
// inspected after the fact (the terminal window isn't always visible). Never
// logs Authorization headers or api keys — only request shape and flow events.
const LOG_DIR = process.env.LOG_DIR || path.join(__dirname, "logs");
const LOG_PATH = path.join(LOG_DIR, "proxy.log");
const LOG_MAX_BYTES = 5 * 1024 * 1024; // rotate at ~5 MB

// How long the upstream may go without sending a single byte before we give up
// on it. Free-tier providers sometimes accept the connection, queue the request
// and then never respond — without this the translation loop waits forever and
// Codex sits on a dead turn with nothing in the log.
const UPSTREAM_IDLE_MS = process.env.UPSTREAM_IDLE_MS ? Number(process.env.UPSTREAM_IDLE_MS) : 120000;
// While upstream is quiet we still send SSE comment heartbeats downstream, so
// Codex's own idle timer never fires on a slow-but-alive provider.
const HEARTBEAT_MS = process.env.HEARTBEAT_MS ? Number(process.env.HEARTBEAT_MS) : 10000;

// ── Upstream rate limiting & retry ──────────────────────────────────────────
// Free-tier providers (e.g. Baseten) cap request rate (e.g. 120 req/min).
// Codex fires many concurrent turns, so we (a) pace outgoing requests with a
// token bucket so we never exceed the provider's rate, and (b) retry with
// backoff when a 429/5xx still slips through — instead of immediately bouncing
// a 502 back to Codex, which only triggers another flood of retries.
//
// The rate is per-provider: each provider in providers.json may declare
// `rateLimitPerMin` (and optionally `rateBurst`). When left empty, the bucket
// runs in AUTO mode — it starts unthrottled and learns the provider's real
// limit from 429 response headers (Retry-After / X-RateLimit-*), so you never
// have to hardcode a limit per provider.
const UPSTREAM_RATE_PER_MIN = process.env.UPSTREAM_RATE_PER_MIN ? Number(process.env.UPSTREAM_RATE_PER_MIN) : 100;
const UPSTREAM_RATE_BURST = process.env.UPSTREAM_RATE_BURST ? Number(process.env.UPSTREAM_RATE_BURST) : 5;
const UPSTREAM_RETRY_MAX = process.env.UPSTREAM_RETRY_MAX ? Number(process.env.UPSTREAM_RETRY_MAX) : 3;
const UPSTREAM_RETRY_BASE_MS = process.env.UPSTREAM_RETRY_BASE_MS ? Number(process.env.UPSTREAM_RETRY_BASE_MS) : 1000;
const UPSTREAM_RETRY_MAX_MS = process.env.UPSTREAM_RETRY_MAX_MS ? Number(process.env.UPSTREAM_RETRY_MAX_MS) : 8000;
// How many times to retry an upstream that returns 200 OK but with NO content
// (no text, no tool calls). Some providers occasionally emit a degenerate
// empty stream — like OpenRouter, we treat that as a transient failure and
// retry instead of silently handing Codex an empty turn.
const UPSTREAM_EMPTY_RETRY_MAX = process.env.UPSTREAM_EMPTY_RETRY_MAX ? Number(process.env.UPSTREAM_EMPTY_RETRY_MAX) : 3;

// Token bucket: refills continuously, allows a small burst, and queues callers
// when the bucket is empty so we never exceed the provider's request rate.
// In "auto" mode (rateLimitPerMin empty) we start unthrottled and learn the
// provider's real limit from 429 response headers, so the user never has to
// hardcode a limit per provider.
class TokenBucket {
  constructor(ratePerMin, burst, auto = false) {
    this.auto = auto;
    this.ratePerMin = ratePerMin;
    this.ratePerSec = ratePerMin / 60;
    this.burst = burst;
    this.tokens = burst;
    this.last = Date.now();
  }
  _refill() {
    const now = Date.now();
    this.tokens = Math.min(this.burst, this.tokens + ((now - this.last) / 1000) * this.ratePerSec);
    this.last = now;
  }
  // Resolve once a token is available and consume it. In auto mode with no
  // detected limit yet, we do not throttle.
  async take() {
    if (this.auto && !Number.isFinite(this.ratePerSec)) return;
    while (this.tokens < 1) {
      this._refill();
      if (this.tokens < 1) await new Promise((r) => setTimeout(r, 50));
    }
    this.tokens -= 1;
  }
  // Learn the provider's real limit from a 429 response's headers. Returns the
  // suggested wait (ms) from Retry-After, or null if none.
  applyRateLimit(headers) {
    if (!this.auto) return null;
    const h = (k) => headers[k] || headers[k.toLowerCase()];
    let waitMs = null;
    const ra = h("retry-after");
    if (ra) {
      const n = Number(ra);
      if (Number.isFinite(n)) waitMs = n * 1000;
      else { const t = Date.parse(ra); if (!Number.isNaN(t)) waitMs = Math.max(0, t - Date.now()); }
    }
    const limit = Number(h("x-ratelimit-limit"));
    const reset = Number(h("x-ratelimit-reset"));
    if (Number.isFinite(limit) && limit > 0) {
      let windowSec = 60;
      if (Number.isFinite(reset) && reset > 0 && reset < 3600) windowSec = reset;
      this.ratePerMin = Math.max(1, Math.round((limit / windowSec) * 60));
      this.ratePerSec = this.ratePerMin / 60;
      this.burst = Math.max(1, Math.round(this.ratePerMin / 20));
      this.tokens = Math.min(this.tokens, this.burst);
      this.last = Date.now();
    }
    return waitMs;
  }
}

// One bucket per provider id, rebuilt only if the provider's *raw* rate/burst
// config changes at runtime (so a learned auto limit is not discarded).
const bucketsByProvider = new Map();
function bucketFor(provider) {
  const rawRate = provider.rateLimitPerMin;
  const rawBurst = provider.rateBurst;
  const existing = bucketsByProvider.get(provider.id);
  if (existing && existing.rawRate === rawRate && existing.rawBurst === rawBurst) return existing;
  const auto = rawRate == null || rawRate === "" || String(rawRate).toLowerCase() === "auto";
  const rate = auto ? Infinity : (Number(rawRate) > 0 ? Number(rawRate) : UPSTREAM_RATE_PER_MIN);
  const burst = (rawBurst == null || rawBurst === "")
    ? Math.max(1, Number.isFinite(rate) ? Math.round(rate / 20) : 5)
    : (Number(rawBurst) > 0 ? Number(rawBurst) : UPSTREAM_RATE_BURST);
  const b = new TokenBucket(rate, burst, auto);
  b.rawRate = rawRate;
  b.rawBurst = rawBurst;
  bucketsByProvider.set(provider.id, b);
  return b;
}

// Statuses worth retrying: rate limit + transient server errors.
function isRetryableStatus(status) {
  return status === 429 || status === 502 || status === 503 || status === 504;
}

// ── Agent behavior guidance ────────────────────────────────────────────────
// Swapped models often skip straight to firing shell commands with no preamble,
// unlike the official Codex agent which narrates and reads the relevant files
// first. We inject this guidance into the system prompt so swapped models mimic
// that workflow. Override with AGENT_GUIDANCE="" (disable) or your own text.
const AGENT_GUIDANCE = process.env.AGENT_GUIDANCE || [
  "You are an autonomous coding agent working in a project directory.",
  "Work deliberately and efficiently. Follow these rules:",
  "1. NARRATE FIRST: before every tool call, write a short text line explaining what you are about to do and why. Never fire a command silently.",
  "2. READ ONCE: read each file you need exactly once. Do NOT re-read the same file or overlapping line ranges repeatedly — that wastes commands. If you already saw a range, do not fetch it again.",
  "3. SEARCH, DON'T DUMP: use targeted searches (rg/grep for specific symbols or patterns) instead of dumping entire large files. Only read the specific line ranges you actually need.",
  "4. PLAN BEFORE EXPLORING: first form a clear plan of which files/functions are relevant, then read only those. Avoid broad, repeated scans of the whole codebase.",
  "5. AVOID REDUNDANCY: do not repeat the same or near-identical command. If a command did not help, reason about why before running a different one.",
  "6. Be deliberate and careful — avoid destructive or irreversible actions without explaining them first.",
  "7. Keep the user informed of what you are doing at each step."
].join("\n");

function ensureLogDir() {
  try { if (!fs.existsSync(LOG_DIR)) fs.mkdirSync(LOG_DIR, { recursive: true }); } catch (e) {}
}
ensureLogDir();

function log(tag, msg) {
  const line = `[${new Date().toISOString()}] [${tag}] ${msg}\n`;
  try {
    // Rotate: keep one .old backup so the file never grows without bound.
    if (fs.existsSync(LOG_PATH) && fs.statSync(LOG_PATH).size > LOG_MAX_BYTES) {
      try { fs.renameSync(LOG_PATH, LOG_PATH + ".old"); } catch (e) {}
    }
    fs.appendFileSync(LOG_PATH, line);
  } catch (e) { /* logging must never crash the request */ }
  process.stdout.write(line);
}

// Logger middleware
app.use((req, res, next) => {
  log("HTTP", `${req.method} ${req.originalUrl}`);
  next();
});

// ── Helpers ──────────────────────────────────────────────────────────────────

function readConfigToml() {
  const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
  return raw;
}

function parseTopLevelValues(raw) {
  const lines = raw.split("\n");
  const result = {
    model: "",
    model_reasoning_effort: "",
    service_tier: "",
    api_base_url: "",
    api_key: "",
    model_provider: "",
    openai_base_url: "",
    chatgpt_base_url: "",
  };

  // TOML puts all top-level keys before the first `[section]` header. Keys
  // inside a section (e.g. `[agents.subagent] model = "..."`) must NOT be
  // treated as the top-level value — otherwise a later section's `model`
  // silently overrides the real one and the picker shows the wrong model.
  let inSection = false;

  for (const line of lines) {
    const trimmed = line.trim();
    if (/^\[.*\]$/.test(trimmed)) {
      inSection = true;
      continue;
    }
    if (inSection) continue;

    const modelMatch = line.match(
      /^model\s*=\s*"([^"]+)"/
    );
    if (modelMatch) {
      result.model = modelMatch[1];
    }

    const providerMatch = line.match(
      /^model_provider\s*=\s*"([^"]+)"/
    );
    if (providerMatch) {
      result.model_provider = providerMatch[1];
    }

    const baseOverrideMatch = line.match(
      /^openai_base_url\s*=\s*"([^"]+)"/
    );
    if (baseOverrideMatch) {
      result.openai_base_url = baseOverrideMatch[1];
    }

    const chatgptMatch = line.match(
      /^chatgpt_base_url\s*=\s*"([^"]+)"/
    );
    if (chatgptMatch) {
      result.chatgpt_base_url = chatgptMatch[1];
    }

    const reasoningMatch = line.match(
      /^model_reasoning_effort\s*=\s*"([^"]+)"/
    );
    if (reasoningMatch) {
      result.model_reasoning_effort = reasoningMatch[1];
    }

    const tierMatch = line.match(
      /^service_tier\s*=\s*"([^"]+)"/
    );
    if (tierMatch) {
      result.service_tier = tierMatch[1];
    }

    const baseUrlMatch = line.match(
      /^api_base_url\s*=\s*"([^"]+)"/
    );
    if (baseUrlMatch) {
      result.api_base_url = baseUrlMatch[1];
    }

    const apiKeyMatch = line.match(
      /^api_key\s*=\s*"([^"]+)"/
    );
    if (apiKeyMatch) {
      result.api_key = apiKeyMatch[1];
    }
  }

  return result;
}

function updateConfigValue(raw, key, value) {
  const regex = new RegExp(`^(${key}\\s*=\\s*)"[^"]*"`, "m");
  if (regex.test(raw)) {
    return raw.replace(regex, `$1"${value}"`);
  }
  // If key doesn't exist, add it at the top (after existing top-level keys)
  const lines = raw.split("\n");
  // Find the last top-level key=value line before any section
  let insertIndex = 0;
  for (let i = 0; i < lines.length; i++) {
    if (/^\s*\[/.test(lines[i])) break;
    if (/^\w+\s*=/.test(lines[i])) insertIndex = i + 1;
  }
  lines.splice(insertIndex, 0, `${key} = "${value}"`);
  return lines.join("\n");
}

function maskUserPath(filePath) {
  return filePath.replace(os.homedir(), path.join(path.dirname(os.homedir()), "XXXXX"));
}

function createBackup() {
  if (!fs.existsSync(BACKUP_DIR)) {
    fs.mkdirSync(BACKUP_DIR, { recursive: true });
  }
  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
  const backupPath = path.join(BACKUP_DIR, `config_${timestamp}.toml`);
  fs.copyFileSync(CONFIG_PATH, backupPath);

  // Keep only last 20 backups
  const backups = fs
    .readdirSync(BACKUP_DIR)
    .filter((f) => f.startsWith("config_") && f.endsWith(".toml"))
    .sort();
  while (backups.length > 20) {
    fs.unlinkSync(path.join(BACKUP_DIR, backups.shift()));
  }

  return backupPath;
}

function loadProviders() {
  try {
    if (fs.existsSync(PROVIDERS_PATH)) {
      return JSON.parse(fs.readFileSync(PROVIDERS_PATH, "utf-8"));
    }
  } catch (err) {}
  return { providers: [], activeProviderId: null };
}

function saveProviders(data) {
  fs.writeFileSync(PROVIDERS_PATH, JSON.stringify(data, null, 2), "utf-8");
}

// ── Model registry & routing ────────────────────────────────────────────────
// With the proxy always on, every request Codex sends (custom AND native GPT
// models) arrives here. We route by the requested model:
//   - "providerKey/modelId"  → the owning custom provider (chat-completions path)
//   - a native GPT model      → ChatGPT passthrough (Responses API, like codex-router)
// The provider key is a slugified, unique provider name so the picker shows
// unambiguous ids even when two providers share a model id (e.g. bynara and
// Rift both serving "gpt-5.6-luna").
const INJECTED_TAG = "__switcher_injected";

function slugify(s) {
  return String(s || "")
    .toLowerCase()
    .trim()
    .replace(/[^a-z0-9]+/g, "-")
    .replace(/^-+|-+$/g, "");
}

// Stable, unique key for a provider, used as the model-id namespace prefix.
function providerKeyFor(provider, allProviders) {
  const base = slugify(provider.name) || String(provider.id);
  const clash = (allProviders || []).some(
    (p) => p.id !== provider.id && (slugify(p.name) || String(p.id)) === base
  );
  return clash ? `${base}-${String(provider.id).slice(0, 6)}` : base;
}

// Read the native (non-injected) model slugs from the cache.
function readNativeModelSlugs() {
  const { data } = readModelsCache();
  if (!data || !Array.isArray(data.models)) return new Set();
  return new Set(
    data.models
      .filter((m) => m && m[INJECTED_TAG] !== true && m.slug)
      .map((m) => m.slug)
  );
}

// Resolve a requested model to a route:
//   { type: "custom", provider, modelId }  → chat-completions translation
//   { type: "native", modelId }            → ChatGPT passthrough
//   { type: "ambiguous", providers }       → un-namespaced id owned by 2+ providers
//   null                                   → unknown model
function resolveModelRoute(model) {
  if (!model) return null;
  const data = loadProviders();
  const enabled = data.providers.filter((p) => p.enabled !== false);

  // 1. Namespaced custom id: "providerKey/modelId"
  const slash = model.indexOf("/");
  if (slash > 0) {
    const key = model.slice(0, slash);
    const modelId = model.slice(slash + 1);
    const provider = enabled.find((p) => providerKeyFor(p, data.providers) === key);
    if (provider && (provider.models || []).includes(modelId)) {
      return { type: "custom", provider, modelId };
    }
  }

  // 2. Native GPT model (not owned by any provider).
  if (readNativeModelSlugs().has(model)) {
    return { type: "native", modelId: model };
  }

  // 3. Legacy un-namespaced custom id — only unambiguous if one provider owns it.
  const owners = enabled.filter((p) => (p.models || []).includes(model));
  if (owners.length === 1) {
    return { type: "custom", provider: owners[0], modelId: model };
  }
  if (owners.length > 1) {
    return { type: "ambiguous", providers: owners };
  }

  return null;
}

// ── Model cache injection ──────────────────────────────────────────────────
// Codex populates its native model picker from `models_cache.json`. To make a
// custom (user-input) provider's models show up in that picker — right next to
// the native GPT models, exactly like codex-router does — we inject synthetic
// model entries into the cache. The injected entries are tagged with
// `__switcher_injected: true` and a `model_provider` pointing at our local
// `customProvider` so Codex routes them through our proxy.
//
// Everything here is reversible: `ejectProviderModels` removes only the entries
// we added (matched by the tag), leaving the real cached models untouched.

// Build a synthetic cache entry for one model id of an enabled provider. The
// slug is namespaced with the provider key so the picker is unambiguous even
// when two providers share a model id. The entry spreads a native model
// template so it carries every field the App expects — the App drops catalog
// entries that are missing required metadata (context_window, input_modalities,
// model_messages, tool_mode, multi_agent_version, ...). No `model_provider`
// field: routing is via `openai_base_url`, and a model_provider made the App
// group the models under "Custom Provider".
function buildInjectedModel(modelId, provider, providerKey, template) {
  const base = template ? { ...template } : {};
  const slug = `${providerKey}/${modelId}`;
  return {
    ...base,
    slug,
    display_name: slug,
    description: `Custom provider: ${provider.name || provider.id}`,
    default_reasoning_level: "medium",
    supported_reasoning_levels: [
      { effort: "low", description: "Fast responses with lighter reasoning" },
      { effort: "medium", description: "Balances speed and reasoning depth for everyday tasks" },
      { effort: "high", description: "Greater reasoning depth for complex problems" },
      { effort: "xhigh", description: "Extra high reasoning depth for complex problems" },
    ],
    shell_type: "shell_command",
    visibility: "list",
    supported_in_api: true,
    priority: 1,
    tool_mode: "code_mode_only",
    // Match codex-router's routedModel shape instead of inheriting native-only
    // capability flags that can make the App silently filter this entry.
    max_context_window: base.context_window,
    effective_context_window_percent: 95,
    auto_compact_token_limit: base.auto_compact_token_limit || null,
    use_responses_lite: false,
    multi_agent_version: "v1",
    service_tiers: [],
    default_service_tier: null,
    availability_nux: null,
    upgrade: null,
    support_verbosity: false,
    default_verbosity: null,
    // No provider_id: Codex hides entries whose provider_id doesn't match
    // any [model_providers.*] table. Routing is via openai_base_url.
    [INJECTED_TAG]: true,
  };
}

// Read the cache safely, returning { data, raw } (data is {} if unreadable).
function readModelsCache() {
  try {
    if (fs.existsSync(MODELS_CACHE_PATH)) {
      const raw = fs.readFileSync(MODELS_CACHE_PATH, "utf-8");
      return { data: JSON.parse(raw), raw };
    }
  } catch (err) {}
  return { data: null, raw: null };
}

// Write the cache with stable 2-space indentation. Codex rewrites this file
// with its own formatter, so we just keep it valid JSON — no need to match its
// exact layout; the next Codex refresh would reformat anyway. We only mark our
// injected entries so we can find and remove them later.
function writeModelsCache(data) {
  fs.writeFileSync(MODELS_CACHE_PATH, JSON.stringify(data, null, 2), "utf-8");
}

// Remove any previously-injected entries (idempotent).
function ejectProviderModels() {
  const { data } = readModelsCache();
  if (!data || !Array.isArray(data.models)) return;
  const before = data.models.length;
  data.models = data.models.filter((m) => !(m && m[INJECTED_TAG] === true));
  if (data.models.length !== before) {
    writeModelsCache(data);
  }
}

// Remove stale injected entries and (re)inject every enabled provider's models.
// Also regenerates the merged catalog file that Codex reads via
// `model_catalog_json` (the mechanism that actually puts custom models in the
// native picker — same as codex-router).
function injectAllProviders() {
  const data = loadProviders();
  const enabled = data.providers.filter((p) => p.enabled !== false);
  const { data: cache } = readModelsCache();
  const base = cache && Array.isArray(cache.models) ? cache : { models: [] };
  // Use the most complete native model as the template for injected entries so
  // they carry the full field set the App requires (same as the merged catalog).
  const native = (cache && Array.isArray(cache.models) ? cache.models : [])
    .filter((m) => m && m[INJECTED_TAG] !== true);
  const template = pickTemplate(native);

  // Drop old injected entries first so re-injecting never duplicates.
  base.models = base.models.filter((m) => !(m && m[INJECTED_TAG] === true));

  for (const provider of enabled) {
    const key = providerKeyFor(provider, data.providers);
    const ids = Array.isArray(provider.models) ? provider.models : [];
    for (const id of ids) {
      if (!id) continue;
      // Don't duplicate an entry that already exists for this exact id.
      if (base.models.some((m) => m && m.slug === `${key}/${id}` && m[INJECTED_TAG] !== true)) continue;
      base.models.push(buildInjectedModel(id, provider, key, template));
    }
  }
  writeModelsCache(base);
  writeMergedCatalog();
}

function refreshProviderCatalog() {
  if (passthroughActive()) {
    injectAllProviders();
    return;
  }
  // Keep native mode isolated from synthetic provider entries and catalogs.
  ejectProviderModels();
  try {
    if (fs.existsSync(MERGED_CATALOG_PATH)) fs.unlinkSync(MERGED_CATALOG_PATH);
  } catch (e) {}
}

// Pick a stable native template for synthetic entries — prefer gpt-5.5 (the
// model codex-router uses), then the first listed native model, then any.
function pickTemplate(nativeModels) {
  const clean = (nativeModels || []).filter(m => m && m[INJECTED_TAG] !== true);
  return (
    clean.find(m => m.slug === "gpt-5.5") ||
    clean.find(m => m.visibility === "list") ||
    clean[0] ||
    null
  );
}

// ── Merged catalog (model_catalog_json) ─────────────────────────────────────
// Codex reads the picker from the file pointed to by `model_catalog_json`.
// We build that file from the native cache plus every enabled provider's
// models. Custom entries carry explicit routedModel-like metadata so the App
// does not silently filter them. provider_id and __switcher_injected are
// stripped — Codex hides entries that carry provider-owned fields when no
// matching [model_providers.*] table exists.

function buildCatalogEntry(modelId, provider, providerKey, template) {
  const base = template ? { ...template } : {};
  delete base[INJECTED_TAG];
  delete base.provider_id;
  const slug = `${providerKey}/${modelId}`;
  return {
    ...base,
    slug,
    display_name: slug,
    description: `Custom provider: ${provider.name || provider.id}`,
    priority: 1,
    visibility: "list",
    supported_in_api: true,
    default_reasoning_level: "medium",
    supported_reasoning_levels: [
      { effort: "low",    description: "Fast responses with lighter reasoning" },
      { effort: "medium", description: "Balances speed and reasoning depth for everyday tasks" },
      { effort: "high",   description: "Greater reasoning depth for complex problems" },
      { effort: "xhigh",  description: "Extra high reasoning depth for complex problems" },
    ],
    context_window: base.context_window || 128000,
    max_context_window: base.context_window || 128000,
    effective_context_window_percent: 95,
    auto_compact_token_limit: base.auto_compact_token_limit || null,
    input_modalities: base.input_modalities || ["text"],
    comp_hash: base.comp_hash || undefined,
    tool_mode: base.tool_mode || "code_mode_only",
    shell_type: "shell_command",
    additional_speed_tiers: [],
    service_tiers: [],
    default_service_tier: null,
    availability_nux: null,
    upgrade: null,
    support_verbosity: false,
    default_verbosity: null,
    supports_reasoning_summaries: false,
    default_reasoning_summary: "none",
    supports_search_tool: false,
    supports_image_detail_original: false,
    use_responses_lite: false,
    apply_patch_tool_type: "freeform",
    multi_agent_version: "v1",
  };
}

// Windows Codex Desktop may only show native-looking model IDs when the
// account is using the local proxy session. Publish up to five external models
// through five native slots and route those slots via native-aliases.json.
function buildMergedCatalog() {
  const { data: cache } = readModelsCache();
  const native = cache && Array.isArray(cache.models)
    ? cache.models.filter(m => m && m[INJECTED_TAG] !== true && m.slug)
    : [];
  const template = pickTemplate(native);
  const data = loadProviders();
  const enabled = data.providers.filter((p) => p.enabled !== false);
  const external = [];
  for (const provider of enabled) {
    const key = providerKeyFor(provider, data.providers);
    for (const id of (provider.models || [])) {
      if (id) external.push({ provider, key, id, canonical: `${key}/${id}` });
    }
  }

  const maxSlots = 5;
  const slots = native.filter(m => m.visibility === "list").slice(0, maxSlots);
  const aliases = {};
  const models = [];
  for (const m of native) {
    if (m.slug && m.visibility !== "hide") models.push(m);
  }
  for (let i = 0; i < Math.min(maxSlots, external.length, slots.length); i++) {
    const source = external[i];
    const slot = slots[i];
    const routed = buildCatalogEntry(source.id, source.provider, source.key, template);
    const index = models.findIndex(m => m.slug === slot.slug);
    if (index < 0) continue;
    aliases[slot.slug] = source.canonical;
    models[index] = {
      ...routed,
      slug: slot.slug,
      display_name: `${source.provider.name || source.provider.id} / ${source.id}`,
      priority: slot.priority,
    };
  }
  writeNativeAliases(aliases);
  return { models: models.slice(0, maxSlots) };
}

// Write the merged catalog file and return its absolute path.
function writeMergedCatalog() {
  fs.writeFileSync(MERGED_CATALOG_PATH, JSON.stringify(buildMergedCatalog(), null, 2), "utf-8");
  return MERGED_CATALOG_PATH;
}

function removeConfigValue(raw, key) {
  const regex = new RegExp(`^${key}\\s*=\\s*"[^"]*"\\n?`, "m");
  return raw.replace(regex, "");
}

// ── API Routes ───────────────────────────────────────────────────────────────

// GET current config
app.get("/api/config", (req, res) => {
  try {
    const raw = readConfigToml();
    const config = parseTopLevelValues(raw);
    // Report auth state so the dashboard can warn when native passthrough
    // won't work: it needs a preserved ChatGPT login (side file or chatgpt mode).
    let authMode = "unknown";
    try {
      if (fs.existsSync(AUTH_PATH)) {
        const auth = JSON.parse(fs.readFileSync(AUTH_PATH, "utf-8"));
        authMode = auth.auth_mode || (auth.tokens ? "chatgpt" : "unknown");
      }
    } catch (e) {}
    const hasChatGptAuth = Boolean(readChatGptTokens());
    res.json({
      success: true,
      config,
      authMode,
      hasChatGptAuth,
      configPath: maskUserPath(CONFIG_PATH),
    });
  } catch (err) {
    res.status(500).json({ success: false, error: err.message });
  }
});

// POST update config
app.post("/api/config", (req, res) => {
  try {
    const { model, model_reasoning_effort, service_tier } = req.body;

    // Create backup first
    const backupPath = createBackup();

    let raw = readConfigToml();

    if (model) {
      raw = updateConfigValue(raw, "model", model);
    }
    if (model_reasoning_effort) {
      raw = updateConfigValue(
        raw,
        "model_reasoning_effort",
        model_reasoning_effort
      );
    }
    if (service_tier) {
      raw = updateConfigValue(raw, "service_tier", service_tier);
    }
    if (typeof req.body.api_base_url === 'string') {
      if (req.body.api_base_url === '') {
        raw = removeConfigValue(raw, 'api_base_url');
      } else {
        raw = updateConfigValue(raw, "api_base_url", req.body.api_base_url);
      }
    }
    if (typeof req.body.api_key === 'string') {
      if (req.body.api_key === '') {
        raw = removeConfigValue(raw, 'api_key');
      } else {
        raw = updateConfigValue(raw, "api_key", req.body.api_key);
      }
    }

    fs.writeFileSync(CONFIG_PATH, raw, "utf-8");

    const updated = parseTopLevelValues(raw);
    res.json({
      success: true,
      config: updated,
      backup: path.basename(backupPath),
    });
  } catch (err) {
    res.status(500).json({ success: false, error: err.message });
  }
});

// GET available models — from the merged catalog when passthrough is active
// (native + custom), else from the native cache.
app.get("/api/models", (req, res) => {
  try {
    const source = passthroughActive() && fs.existsSync(MERGED_CATALOG_PATH)
      ? MERGED_CATALOG_PATH
      : MODELS_CACHE_PATH;
    const raw = fs.readFileSync(source, "utf-8");
    const data = JSON.parse(raw);
    const models = (data.models || []).map((m) => ({
      slug: m.slug,
      display_name: m.display_name,
      description: m.description || "",
      default_reasoning_level: m.default_reasoning_level || "medium",
      supported_reasoning_levels: m.supported_reasoning_levels || [],
    }));
    res.json({ success: true, models });
  } catch (err) {
    res.json({ success: true, models: [] });
  }
});

// GET backups list
app.get("/api/backups", (req, res) => {
  try {
    if (!fs.existsSync(BACKUP_DIR)) {
      return res.json({ success: true, backups: [] });
    }
    const backups = fs
      .readdirSync(BACKUP_DIR)
      .filter((f) => f.startsWith("config_") && f.endsWith(".toml"))
      .sort()
      .reverse()
      .slice(0, 10)
      .map((f) => ({
        name: f,
        date: f
          .replace("config_", "")
          .replace(".toml", "")
          .replace(/-/g, (m, i) => (i < 16 ? (i === 10 ? "T" : ":") : ".")),
      }));
    res.json({ success: true, backups });
  } catch (err) {
    res.status(500).json({ success: false, error: err.message });
  }
});

// POST restore backup
app.post("/api/restore", (req, res) => {
  try {
    const { name } = req.body;
    const backupPath = path.join(BACKUP_DIR, name);
    if (!fs.existsSync(backupPath)) {
      return res.status(404).json({ success: false, error: "Backup not found" });
    }
    // Backup current before restoring
    createBackup();
    fs.copyFileSync(backupPath, CONFIG_PATH);
    const raw = readConfigToml();
    const config = parseTopLevelValues(raw);
    res.json({ success: true, config });
  } catch (err) {
    res.status(500).json({ success: false, error: err.message });
  }
});

// ── Custom Providers ─────────────────────────────────────────────────────────

// GET all custom providers
app.get("/api/providers", (req, res) => {
  try {
    const data = loadProviders();
    res.json({ success: true, ...data });
  } catch (err) {
    res.status(500).json({ success: false, error: err.message });
  }
});

// POST add/update a provider
app.post("/api/providers", (req, res) => {
  try {
    const { id, name, baseUrl, apiKey, models, rateLimitPerMin, rateBurst, enabled } = req.body;
    const data = loadProviders();
    const rateLimit = rateLimitPerMin != null && rateLimitPerMin !== "" ? Number(rateLimitPerMin) : undefined;
    const burst = rateBurst != null && rateBurst !== "" ? Number(rateBurst) : undefined;
    
    if (id) {
      // Update existing
      const idx = data.providers.findIndex(p => p.id === id);
      if (idx !== -1) {
        const updated = {
          ...data.providers[idx],
          name, baseUrl, apiKey,
          models: models || [],
        };
        // Empty rate limit/burst means AUTO: remove the field so the proxy
        // auto-detects the provider's real limit instead of keeping a stale value.
        if (rateLimit !== undefined) updated.rateLimitPerMin = rateLimit;
        else delete updated.rateLimitPerMin;
        if (burst !== undefined) updated.rateBurst = burst;
        else delete updated.rateBurst;
        if (typeof enabled === "boolean") updated.enabled = enabled;
        data.providers[idx] = updated;
      }
    } else {
      // Add new
      const newProvider = {
        id: Date.now().toString(36) + Math.random().toString(36).slice(2, 6),
        name,
        baseUrl,
        apiKey,
        models: models || [],
        enabled: enabled !== false,
        ...(rateLimit !== undefined ? { rateLimitPerMin: rateLimit } : {}),
        ...(burst !== undefined ? { rateBurst: burst } : {}),
      };
      data.providers.push(newProvider);
    }
    
    saveProviders(data);
    // Reflect the new enabled set in the picker immediately when passthrough is active.
    refreshProviderCatalog();
    res.json({ success: true, ...data });
  } catch (err) {
    res.status(500).json({ success: false, error: err.message });
  }
});

// DELETE a provider
app.delete("/api/providers/:id", (req, res) => {
  try {
    const data = loadProviders();
    data.providers = data.providers.filter(p => p.id !== req.params.id);
    if (data.activeProviderId === req.params.id) {
      data.activeProviderId = null;
    }
    saveProviders(data);
    // Rebuild the picker without the deleted provider's models when active.
    refreshProviderCatalog();
    res.json({ success: true, ...data });
  } catch (err) {
    res.status(500).json({ success: false, error: err.message });
  }
});

// ── Passthrough mode ────────────────────────────────────────────────────────
// The proxy is always-on: config.toml points `model_provider` at our local
// proxy, and the proxy routes each request by model (custom provider model →
// that provider; native GPT model → ChatGPT). Enabling passthrough writes that
// config and injects every enabled provider's models into the picker; disabling
// it restores the native config and ejects the injected models.
//
// AUTH: this Codex build ignores custom-provider routing while in ChatGPT mode
// (it stays on chatgpt.com). So enabling passthrough switches auth.json to
// apikey mode — the proven way to force all model traffic through the proxy —
// and stashes the ChatGPT OAuth tokens in AUTH_CHATGPT_PATH first. The proxy
// uses those stashed tokens for native GPT passthrough. Disabling passthrough
// restores the ChatGPT auth so the user stays logged in.

// If auth.json currently holds ChatGPT OAuth tokens, preserve them to the side
// file before we switch to apikey mode.
function preserveChatGptAuth() {
  try {
    if (!fs.existsSync(AUTH_PATH)) return;
    const auth = JSON.parse(fs.readFileSync(AUTH_PATH, "utf-8"));
    if (auth.auth_mode === "chatgpt" || auth.tokens) {
      fs.writeFileSync(AUTH_CHATGPT_PATH, JSON.stringify(auth, null, 2), "utf-8");
      log("AUTH", "preserved ChatGPT OAuth credentials for native passthrough");
    }
  } catch (err) {
    log("AUTH", `preserve failed: ${err.message}`);
  }
}

// Restore the preserved ChatGPT auth (used when passthrough is disabled).
function restoreChatGptAuth() {
  try {
    if (fs.existsSync(AUTH_CHATGPT_PATH)) {
      fs.copyFileSync(AUTH_CHATGPT_PATH, AUTH_PATH);
      log("AUTH", "restored ChatGPT OAuth credentials");
    }
  } catch (err) {
    log("AUTH", `restore failed: ${err.message}`);
  }
}

// Read ChatGPT OAuth tokens for native passthrough: from the preserved side
// file first (apikey mode active), else from auth.json if it is chatgpt mode.
function readChatGptTokens() {
  const candidates = [AUTH_CHATGPT_PATH, AUTH_PATH];
  for (const p of candidates) {
    try {
      if (!fs.existsSync(p)) continue;
      const auth = JSON.parse(fs.readFileSync(p, "utf-8"));
      if (auth.tokens && auth.tokens.access_token) {
        return { accessToken: auth.tokens.access_token, accountId: auth.tokens.account_id };
      }
    } catch (e) {}
  }
  return null;
}

// ── Managed config helpers ────────────────────────────────────────────────────
// We wrap managed root keys (openai_base_url, model_catalog_json) and the
// managed provider table [model_providers.codex-router] in comment markers so
// we can remove only our own sections on disable, never touching the user's
// native model_provider, chatgpt_base_url, model, or auth settings.

function removeManagedRoot(raw, key) {
  // Remove a managed key=value line that sits between our markers.
  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  const regex = new RegExp(`\n?${MANAGED_START}[\\s\\S]*?^${escaped}\\s*=\\s*"[^"]*"[\\s\\S]*?${MANAGED_END}`, "m");
  return raw.replace(regex, match => {
    // Keep the markers but strip just the key=value line.
    return match.replace(new RegExp(`^\\s*${escaped}\\s*=\\s*"[^"]*"\\n?`, "m"), "");
  });
}

function hasManagedProviderBlock(raw) {
  return raw.includes(MANAGED_PROVIDER_START) && raw.includes(MANAGED_PROVIDER_END);
}

function removeManagedProviderBlock(raw) {
  const regex = new RegExp(`\n?${MANAGED_PROVIDER_START}[\s\S]*?${MANAGED_PROVIDER_END}`, "m");
  return raw.replace(regex, "");
}

// ── Config apply / remove ─────────────────────────────────────────────────────

function createManagedRootBlock(catalogPath) {
  return `${MANAGED_START}\nopenai_base_url = "http://127.0.0.1:${PORT}/v1"\nmodel_catalog_json = "${catalogPath.replace(/\\/g, "\\\\")}"\n${MANAGED_END}`;
}

function removeManagedRootBlock(raw) {
  if (!raw.includes(MANAGED_START) || !raw.includes(MANAGED_END)) return raw;
  const start = raw.indexOf(MANAGED_START);
  const endMarker = raw.indexOf(MANAGED_END, start);
  if (endMarker < 0) return raw;
  const after = raw.indexOf("\n", endMarker + MANAGED_END.length);
  return raw.slice(0, start) + (after < 0 ? "" : raw.slice(after + 1));
}

function applyPassthroughConfig(raw, subagentModel) {
  // Remove legacy root values and any prior managed block first, then write one
  // canonical block. Never touch model_provider, model, chatgpt_base_url, or auth.
  raw = removeConfigValue(raw, 'api_base_url');
  raw = removeConfigValue(raw, 'api_key');
  raw = removeConfigValue(raw, 'openai_base_url');
  raw = removeConfigValue(raw, 'model_catalog_json');
  raw = removeManagedRootBlock(raw);
  raw = removeManagedProviderBlock(raw);
  // Remove any legacy managed provider table, including the old codex-router
  // block. This project intentionally uses no [model_providers.*] entry.
  raw = raw.replace(/\n*# BEGIN codex-switcher-provider-managed[\s\S]*?# END codex-switcher-provider-managed\n?/g, "");
  raw = raw.replace(/\n*\[model_providers\.customProvider\][\s\S]*?(?=\n\[|$)/g, "");

  const catalogPath = writeMergedCatalog();
  const block = createManagedRootBlock(catalogPath);
  const lines = raw.split("\n");
  let insertIndex = lines.findIndex(line => /^\s*\[/.test(line));
  if (insertIndex < 0) insertIndex = lines.length;
  lines.splice(insertIndex, 0, block, "");
  return lines.join("\n");
}

function managedRootValue(raw, key, value) {
  // Write a key=value inside the managed marker block. Replace existing managed
  // value or append at the end of the managed block.
  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  const managedRegex = new RegExp(`(${escaped}\\s*=\\s*)"[^"]*"`);
  if (raw.includes(MANAGED_START) && managedRegex.test(raw)) {
    return raw.replace(managedRegex, `$1"${value}"`);
  }
  // Append inside the managed block.
  if (raw.includes(MANAGED_START) && raw.includes(MANAGED_END)) {
    return raw.replace(
      new RegExp(`(${MANAGED_END})`),
      `${key} = "${value}"\n$1`
    );
  }
  // No managed block yet — create one at the top, before any [section].
  const lines = raw.split("\n");
  let insertIndex = 0;
  for (let i = 0; i < lines.length; i++) {
    if (/^\s*\[/.test(lines[i])) { insertIndex = i; break; }
    if (/\w+\s*=/.test(lines[i])) insertIndex = i + 1;
  }
  lines.splice(insertIndex, 0, MANAGED_START, `openai_base_url = "http://127.0.0.1:${PORT}/v1"`, `model_catalog_json = "${value.replace(/\\/g, "\\\\")}"`, MANAGED_END, "");
  return lines.join("\n");
}

function removePassthroughConfig(raw) {
  // Only remove what we wrote; never touch the user's native config.
  raw = removeConfigValue(raw, 'api_base_url');
  raw = removeConfigValue(raw, 'api_key');

  // Remove managed root block (openai_base_url + model_catalog_json).
  raw = removeManagedRootBlock(raw);

  // Remove any stale managed provider block from older iterations.
  if (hasManagedProviderBlock(raw)) raw = removeManagedProviderBlock(raw);

  // Remove stale customProvider / agents.subagent that may exist from old runs.
  raw = raw.replace(/\n*\[model_providers\.customProvider\][\s\S]*?(?=\n\[|$)/g, "");

  // Remove the managed catalog file so Codex falls back to its native catalog.
  try { if (fs.existsSync(MERGED_CATALOG_PATH)) fs.unlinkSync(MERGED_CATALOG_PATH); } catch (e) {}
  return raw;
}

function ensureSubagentConfig(raw, model) {
  if (!model || /^\s*\[agents\.subagent\]\s*$/m.test(raw)) return raw;
  return `${raw.trimEnd()}\n\n[agents.subagent]\nmodel = ${JSON.stringify(model)}\n`;
}

// Pick a sensible default model for the subagent: prefer the current model
// (including a native alias), else the first generated alias, else the first
// enabled provider's canonical model.
function defaultSubagentModel(raw) {
  const current = parseTopLevelValues(raw).model;
  const aliases = readNativeAliases();
  if (current && (aliases[current] || resolveModelRoute(current))) return current;
  const firstAlias = Object.keys(aliases)[0];
  if (firstAlias) return firstAlias;
  const data = loadProviders();
  const provider = data.providers.find((p) => p.enabled !== false && (p.models || []).length);
  if (provider) return `${providerKeyFor(provider, data.providers)}/${provider.models[0]}`;
  return "";
}

// POST /api/passthrough/enable — turn on managed routing via model_catalog_json.
app.post("/api/passthrough/enable", (req, res) => {
  try {
    const backupPath = createBackup();
    let raw = readConfigToml();
    raw = applyPassthroughConfig(raw);
    raw = ensureSubagentConfig(raw, defaultSubagentModel(raw));
    fs.writeFileSync(CONFIG_PATH, raw, "utf-8");
    refreshProviderCatalog();
    const config = parseTopLevelValues(raw);
    res.json({ success: true, config, backup: path.basename(backupPath) });
  } catch (err) {
    res.status(500).json({ success: false, error: err.message });
  }
});

// POST /api/passthrough/disable — restore native config.
app.post("/api/passthrough/disable", (req, res) => {
  try {
    const backupPath = createBackup();
    let raw = readConfigToml();
    raw = removePassthroughConfig(raw);
    fs.writeFileSync(CONFIG_PATH, raw, "utf-8");
    ejectProviderModels();
    const config = parseTopLevelValues(raw);
    res.json({ success: true, config, backup: path.basename(backupPath) });
  } catch (err) {
    res.status(500).json({ success: false, error: err.message });
  }
});

// Backward-compatible wrapper: the old single-active-provider flow now maps to
// passthrough mode. Activating a provider enables passthrough and marks that
// provider enabled; deactivating disables passthrough.
app.post("/api/providers/activate", (req, res) => {
  try {
    const { providerId } = req.body;
    if (!providerId) {
      const backupPath = createBackup();
      let raw = readConfigToml();
      raw = removePassthroughConfig(raw);
      fs.writeFileSync(CONFIG_PATH, raw, "utf-8");
      ejectProviderModels();
      const data = loadProviders();
      data.activeProviderId = null;
      saveProviders(data);
      const config = parseTopLevelValues(raw);
      return res.json({ success: true, config, backup: path.basename(backupPath) });
    }
    const data = loadProviders();
    const provider = data.providers.find(p => p.id === providerId);
    if (!provider) {
      return res.status(404).json({ success: false, error: "Provider not found" });
    }
    provider.enabled = true;
    data.activeProviderId = providerId;
    saveProviders(data);
    const backupPath = createBackup();
    let raw = readConfigToml();
    raw = applyPassthroughConfig(raw, defaultSubagentModel(raw));
    fs.writeFileSync(CONFIG_PATH, raw, "utf-8");
    refreshProviderCatalog();
    const config = parseTopLevelValues(raw);
    res.json({ success: true, config, provider: provider.name, backup: path.basename(backupPath) });
  } catch (err) {
    res.status(500).json({ success: false, error: err.message });
  }
});

// ── Local Proxy Server ───────────────────────────────────────────────────────

app.get("/v1/models", (req, res) => {
  try {
    const data = loadProviders();
    const enabled = data.providers.filter((p) => p.enabled !== false);

    // Build a lookup: slug → owned_by (per provider name, matching codex-router).
    // Native aliases are exposed with native-looking IDs so Desktop can list them.
    const aliases = readNativeAliases();
    const ownedBy = new Map();
    const ids = [];
    for (const provider of enabled) {
      const key = providerKeyFor(provider, data.providers);
      const owned = provider.name || provider.id;
      for (const id of (provider.models || [])) {
        if (id) {
          const slug = `${key}/${id}`;
          ownedBy.set(slug, owned);
          ids.push(slug);
        }
      }
    }
    for (const slug of readNativeModelSlugs()) {
      if (!ids.includes(slug)) {
        ownedBy.set(slug, "openai");
        ids.push(slug);
      }
    }

    res.json({
      object: "list",
      data: ids.map((id) => ({
        id,
        object: "model",
        created: 1686935002,
        owned_by: ownedBy.get(id) || "openai",
        permission: [],
        root: id,
        parent: null,
      })),
    });
  } catch (err) {
    res.status(500).json({ error: "Failed to read local config" });
  }
});

// ── Codex Translation Proxy ──────────────────────────────────────────────────

// Random suffix for synthetic call/item ids.
function rid() {
  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
}

// Summarize a tool call for the log so we can inspect what the model actually
// asked to run. For shell-like tools we surface the command text; otherwise we
// fall back to the raw JSON arguments, truncated.
function summarizeToolCall(acc) {
  const head = `${acc.name}#${acc.id}`;
  let detail = "";
  try {
    const parsed = JSON.parse(acc.args || "{}");
    const cmd = parsed.command ?? parsed.cmd ?? parsed.input ?? parsed.script ?? parsed.arguments;
    if (typeof cmd === "string") detail = cmd;
    else if (parsed && Object.keys(parsed).length) detail = JSON.stringify(parsed);
  } catch (e) {
    detail = String(acc.args || "");
  }
  detail = detail.replace(/\s+/g, " ").trim();
  if (detail.length > 200) detail = detail.slice(0, 200) + "…";
  return detail ? `${head} :: ${detail}` : head;
}

// Turn one upstream chat-completions tool_call into the Responses output item
// Codex expects. Custom (grammar) tools are unwrapped from the {"input": "..."}
// envelope we asked the model to fill.
function toolCallToOutputItem(tc, i, customToolNames) {
  const callId = tc.id || `call_${rid()}_${i}`;
  const name = tc.function?.name || "";
  const rawArgs = tc.function?.arguments || "{}";
  if (customToolNames.has(name)) {
    let input = rawArgs;
    try {
      const parsed = JSON.parse(rawArgs);
      if (parsed && typeof parsed.input === "string") input = parsed.input;
    } catch (e) {}
    return { id: `ctc_${rid()}_${i}`, type: "custom_tool_call", status: "completed", call_id: callId, name, input };
  }
  return { id: `fc_${rid()}_${i}`, type: "function_call", status: "completed", call_id: callId, name, arguments: rawArgs };
}

// Translate a *complete* chat-completions assistant message into Responses
// output items (used for the non-streaming / buffered fallback path).
function chatMessageToOutputItems(message, customToolNames) {
  const output = [];
  let content = message.content || "";
  if (Array.isArray(content)) content = content.map(p => (typeof p === "string" ? p : p.text || "")).join("\n");
  if (content) {
    output.push({
      id: "msg_" + rid(),
      type: "message",
      status: "completed",
      role: "assistant",
      content: [{ type: "output_text", text: content, annotations: [] }],
    });
  }
  if (Array.isArray(message.tool_calls)) {
    for (let i = 0; i < message.tool_calls.length; i++) {
      output.push(toolCallToOutputItem(message.tool_calls[i], i, customToolNames));
    }
  }
  return output;
}

function buildResponseBody(output, model, usage) {
  return {
    id: "resp_" + rid(),
    object: "response",
    created_at: Math.floor(Date.now() / 1000),
    status: "completed",
    model,
    output,
    usage: {
      input_tokens: usage?.prompt_tokens || 0,
      output_tokens: usage?.completion_tokens || 0,
      total_tokens: usage?.total_tokens || 0,
    },
  };
}

// Emit the full set of SSE events for a single already-complete output item.
function emitItemEvents(sendSSE, item, index) {
  sendSSE("response.output_item.added", { type: "response.output_item.added", output_index: index, item });
  if (item.type === "message" && Array.isArray(item.content)) {
    for (let c = 0; c < item.content.length; c++) {
      const part = item.content[c];
      if (part.type === "output_text" && part.text) {
        sendSSE("response.output_text.delta", { type: "response.output_text.delta", item_id: item.id, output_index: index, content_index: c, delta: part.text });
        sendSSE("response.output_text.done", { type: "response.output_text.done", item_id: item.id, output_index: index, content_index: c, text: part.text });
      }
    }
  } else if (item.type === "function_call") {
    sendSSE("response.function_call_arguments.delta", { type: "response.function_call_arguments.delta", item_id: item.id, output_index: index, delta: item.arguments || "{}" });
    sendSSE("response.function_call_arguments.done", { type: "response.function_call_arguments.done", item_id: item.id, output_index: index, arguments: item.arguments || "{}" });
  } else if (item.type === "custom_tool_call") {
    sendSSE("response.custom_tool_call_input.delta", { type: "response.custom_tool_call_input.delta", item_id: item.id, output_index: index, delta: item.input || "" });
    sendSSE("response.custom_tool_call_input.done", { type: "response.custom_tool_call_input.done", item_id: item.id, output_index: index, input: item.input || "" });
  }
  sendSSE("response.output_item.done", { type: "response.output_item.done", output_index: index, item });
}

// Emit a terminal `error` event into an SSE response whose head is already
// sent, without ending it — the caller decides when the stream is over.
//
// The frame is prefixed with a blank line because the stream is often ending
// mid-line: a single `output_text.delta` can carry a long span, and writing
// `event: error` straight onto an unterminated `data:` line would make a
// conforming parser read the field name as more of the previous event's data —
// the failure would turn into garbage appended to the last delta. Leading
// newlines are inert when the stream ended cleanly. The message is always our
// own text, never upstream error text, so no response body leaks through.
// (Same framing as codex-router's writeStreamErrorEvent.)
function writeStreamErrorEvent(res, { code, message }) {
  if (!res || res.writableEnded || res.destroyed) return false;
  try {
    const data = { type: "error", code, message, param: null };
    res.write(`\n\nevent: error\ndata: ${JSON.stringify(data)}\n\n`);
    return true;
  } catch {
    return false;
  }
}

// Send a 502 error to Codex when the upstream repeatedly returns
// empty/degenerate responses and we've exhausted our empty-response retry
// budget. Nothing has been relayed at this point (the stream path uses delayed
// commit), so a plain JSON error is safe — Codex surfaces it instead of
// silently ending a turn with nothing to show. (Same approach as codex-router's
// writeEmptyCompletionError.)
function sendEmptyCompletionError(res, code, message) {
  if (res.headersSent) {
    // Never write JSON onto an already-streaming response; end it with a
    // proper error event instead.
    writeStreamErrorEvent(res, { code, message });
    try { res.end(); } catch (e) {}
    return;
  }
  res.status(502).json({
    error: { type: code, code, message },
  });
}

// @@STREAM_HELPER@@

// True streaming passthrough: read the upstream chat-completions SSE stream and
// translate each delta into Responses API events as it arrives, so Codex keeps
// receiving bytes and never trips its idle timeout on long turns.
//
// Chat-completions streams text in `choices[0].delta.content` chunks and tool
// calls in `choices[0].delta.tool_calls[]` fragments (name arrives once, then
// `arguments` accumulates across many deltas, keyed by `index`). We reassemble
// those, emitting Responses deltas live for text and flushing each tool call
// once the stream finishes.
async function streamUpstreamToResponses(upstreamRes, res, ctx) {
  const { customToolNames, fallbackModel, reqId = "?", abortUpstream } = ctx;
  const tag = `#${reqId}`;

  const sendSSE = (event, dataObj) => {
    res.write(`event: ${event}\ndata: ${JSON.stringify(dataObj)}\n\n`);
  };

  let outputIndex = 0;
  let model = fallbackModel;
  let usage = null;
  const streamStart = Date.now();

  // Live text message state.
  let textItem = null;      // the message item currently open
  let textItemId = null;    // its id, retained after close for the final event
  let textContentIndex = 0;

  // Accumulating tool calls, keyed by upstream delta index.
  const toolAcc = new Map(); // idx -> { id, name, args }

  // ── Delayed commit ────────────────────────────────────────────────────────
  // We do NOT send response.created/headers to Codex until we see the first
  // real content (text delta or tool_call fragment). This way, if the upstream
  // returns 200 OK but an empty stream (a degenerate response some providers
  // emit under load), we can signal the caller to retry — instead of silently
  // handing Codex an empty turn that ends with nothing to show.
  let committed = false;
  const commit = () => {
    if (committed) return;
    committed = true;
    res.setHeader("Content-Type", "text/event-stream");
    res.setHeader("Cache-Control", "no-cache");
    res.setHeader("Connection", "keep-alive");
    if (typeof res.flushHeaders === "function") res.flushHeaders();
    const created = buildResponseBody([], model, null);
    created.status = "in_progress";
    sendSSE("response.created", { type: "response.created", response: created });
  };

  const openTextItem = () => {
    commit(); // first real content → commit the stream to Codex
    if (textItem) return;
    textItemId = "msg_" + rid();
    textItem = { id: textItemId, type: "message", status: "in_progress", role: "assistant", content: [] };
    sendSSE("response.output_item.added", { type: "response.output_item.added", output_index: outputIndex, item: textItem });
  };
  const closeTextItem = (fullText) => {
    if (!textItem) return;
    sendSSE("response.output_text.done", { type: "response.output_text.done", item_id: textItem.id, output_index: outputIndex, content_index: textContentIndex, text: fullText });
    const done = { ...textItem, status: "completed", content: [{ type: "output_text", text: fullText, annotations: [] }] };
    sendSSE("response.output_item.done", { type: "response.output_item.done", output_index: outputIndex, item: done });
    textItem = null;
    outputIndex++;
  };

  let textBuf = "";
  // Stream end diagnostics: why did the loop finish, and what did upstream say?
  let finishReason = null;
  let sawDone = false;
  let endReason = "upstream closed";
  let lastByteAt = Date.now();
  let bytesIn = 0;
  let clientGone = false;

  // Parse the SSE byte stream line-by-line, buffering partial lines.
  const decoder = new TextDecoder();
  let buf = "";

  const handleChatChunk = (json) => {
    // NOTE: do NOT adopt json.model from the upstream — Codex displays the model
    // name from the response, and providers often return their own internal id
    // (e.g. a versioned/aliased slug) which differs from what the user configured.
    // Keeping fallbackModel ensures Codex shows the name the user picked.
    if (json.usage) usage = json.usage;
    const choice = json.choices && json.choices[0];
    if (!choice) return;
    if (choice.finish_reason) finishReason = choice.finish_reason;
    const delta = choice.delta || {};

    if (typeof delta.content === "string" && delta.content.length) {
      openTextItem();
      textBuf += delta.content;
      sendSSE("response.output_text.delta", { type: "response.output_text.delta", item_id: textItem.id, output_index: outputIndex, content_index: textContentIndex, delta: delta.content });
    }

    if (Array.isArray(delta.tool_calls) && delta.tool_calls.length) {
      commit(); // first tool-call fragment → commit the stream to Codex
      for (const tc of delta.tool_calls) {
        const idx = tc.index != null ? tc.index : 0;
        let acc = toolAcc.get(idx);
        if (!acc) { acc = { id: tc.id || null, name: "", args: "" }; toolAcc.set(idx, acc); }
        if (tc.id) acc.id = tc.id;
        if (tc.function?.name) acc.name += tc.function.name;
        if (tc.function?.arguments) acc.args += tc.function.arguments;
      }
    }
  };

  // Codex hangs silently if the upstream accepts the connection and then never
  // answers, so watch two things while we read: keep the downstream socket warm
  // with SSE comments, and abort a provider that has gone quiet for too long.
  const onClientClose = () => {
    if (res.writableEnded) return; // normal completion, not a disconnect
    clientGone = true;
    endReason = "client disconnected";
    log("STREAM", `${tag} client disconnected mid-stream — aborting upstream`);
    if (abortUpstream) { try { abortUpstream(); } catch (e) {} }
  };
  res.on("close", onClientClose);

  const watchdog = setInterval(() => {
    const quietMs = Date.now() - lastByteAt;
    if (quietMs >= UPSTREAM_IDLE_MS) {
      endReason = `upstream idle ${Math.round(quietMs / 1000)}s (limit ${Math.round(UPSTREAM_IDLE_MS / 1000)}s)`;
      log("STREAM", `${tag} ${endReason} — aborting upstream`);
      if (abortUpstream) { try { abortUpstream(); } catch (e) {} }
      return;
    }
    // Only heartbeat once we've committed (headers sent); before commit there
    // is no stream to keep warm, and we must not write to an uncommitted res.
    if (committed && quietMs >= HEARTBEAT_MS) {
      try { res.write(": keepalive\n\n"); } catch (e) {}
    }
  }, HEARTBEAT_MS);

  try {
    for await (const chunk of upstreamRes.body) {
      lastByteAt = Date.now();
      bytesIn += chunk.length || 0;
      buf += decoder.decode(chunk, { stream: true });
      let nl;
      while ((nl = buf.indexOf("\n")) !== -1) {
        const line = buf.slice(0, nl).trim();
        buf = buf.slice(nl + 1);
        if (!line || !line.startsWith("data:")) continue;
        const payload = line.slice(5).trim();
        if (payload === "[DONE]") { sawDone = true; continue; }
        try { handleChatChunk(JSON.parse(payload)); } catch (e) { /* ignore keep-alives / partials */ }
      }
    }
  } catch (err) {
    // A stalled or dropped upstream must not leave Codex waiting forever — fall
    // through and close the response out with whatever we managed to collect.
    if (endReason === "upstream closed") {
      endReason = `upstream read error: ${err.message}`;
      log("STREAM", `${tag} ${endReason}`);
    }
  } finally {
    clearInterval(watchdog);
    res.off("close", onClientClose);
  }

  if (clientGone) {
    log("STREAM", `${tag} aborted after ${Date.now() - streamStart}ms | ${endReason} | text=${textBuf.length}ch toolCalls=${toolAcc.size} bytesIn=${bytesIn}`);
    try { res.end(); } catch (e) {}
    return { empty: false, clientGone: true };
  }

  // ── Empty-stream detection (delayed-commit path) ─────────────────────────
  // If the upstream returned 200 OK but produced no text and no tool calls, we
  // never committed — so Codex has received nothing. Signal the caller to retry
  // instead of sending a silent empty response.completed.
  if (!committed && !textBuf && toolAcc.size === 0) {
    log("STREAM", `${tag} empty response (never committed, ${bytesIn} bytes) — signaling caller to retry`);
    return { empty: true, bytesIn, finishReason };
  }

  // ── Mid-stream upstream failure ───────────────────────────────────────────
  // If the upstream died or went idle after we already committed (headers sent,
  // deltas streamed), a clean response.completed would make Codex treat the
  // partial turn as a success. Emit a proper Responses `error` event instead so
  // Codex surfaces the failure — same framing as codex-router's
  // endStreamedResponse. Partial tool calls are deliberately NOT flushed: a
  // half-assembled call would be executed with garbage arguments.
  if (committed && (endReason.startsWith("upstream idle") || endReason.startsWith("upstream read error"))) {
    log("STREAM", `${tag} upstream failed mid-stream after commit — sending error event | ${endReason} | text=${textBuf.length}ch toolCalls=${toolAcc.size} bytesIn=${bytesIn}`);
    if (textItem) closeTextItem(textBuf);
    writeStreamErrorEvent(res, {
      code: "upstream_stream_failed",
      message: "The upstream provider lost the response stream mid-turn. Please try again.",
    });
    res.write("event: done\ndata: [DONE]\n\n");
    res.end();
    return { empty: false, failed: true };
  }

  // Close out the live text item.
  if (textItem) closeTextItem(textBuf);

  // Build the final aggregate output for response.completed. CRITICAL: every
  // item here must be the SAME object (same id + call_id) that we already
  // streamed to Codex — Codex maps tool results back by call_id, so a fresh
  // random id in the completed event would orphan the tool call and stall the
  // turn. So we assemble finalOutput from the exact items we emit.
  const finalOutput = [];
  if (textBuf) finalOutput.push({ id: textItemId, type: "message", status: "completed", role: "assistant", content: [{ type: "output_text", text: textBuf, annotations: [] }] });

  // Flush any accumulated tool calls as complete items, reusing each built item.
  const orderedIdx = [...toolAcc.keys()].sort((a, b) => a - b);
  for (let n = 0; n < orderedIdx.length; n++) {
    const acc = toolAcc.get(orderedIdx[n]);
    // Ensure a stable call_id even when upstream never supplied one, so the
    // streamed item and the completed item share it.
    if (!acc.id) acc.id = `call_${rid()}_${n}`;
    const tc = { id: acc.id, function: { name: acc.name, arguments: acc.args || "{}" } };
    const item = toolCallToOutputItem(tc, n, customToolNames);
    emitItemEvents(sendSSE, item, outputIndex);
    outputIndex++;
    finalOutput.push(item);
  }

  const toolSummary = orderedIdx.length
    ? " [" + orderedIdx.map(k => summarizeToolCall(toolAcc.get(k))).join(" | ") + "]"
    : "";
  log("STREAM", `${tag} done in ${Date.now() - streamStart}ms | text=${textBuf.length}ch toolCalls=${orderedIdx.length}${toolSummary} | finish=${finishReason || "none"} end="${endReason}" done_sentinel=${sawDone} bytesIn=${bytesIn} | tokens in/out=${usage ? usage.prompt_tokens + "/" + usage.completion_tokens : "?"}`);
  sendSSE("response.completed", { type: "response.completed", response: buildResponseBody(finalOutput, model, usage) });
  res.write("event: done\ndata: [DONE]\n\n");
  res.end();
  return { empty: false };
}

// ── Native ChatGPT passthrough ──────────────────────────────────────────────
// Native GPT models (gpt-5.6-terra, ...) are NOT translated — Codex and
// chatgpt.com both speak the Responses API, so we forward the request verbatim
// and pipe the response back. The ChatGPT OAuth token arrives on the incoming
// request as the `authorization` header (Codex is in chatgpt mode) and is
// copied through, exactly like codex-router's nativeHeaders allowlist.
// The native target base URL comes from `chatgpt_base_url` in config.toml
// (codex-router style), with a fallback if absent.
const NATIVE_FORWARD_HEADERS = [
  "authorization", "chatgpt-account-id", "openai-beta", "originator",
  "session_id", "session-id", "thread-id", "x-client-request-id",
  "x-codex-beta-features", "x-codex-installation-id", "x-codex-parent-thread-id",
  "x-codex-turn-metadata", "x-codex-turn-state", "x-codex-window-id",
  "x-oai-attestation", "x-openai-subagent", "x-responsesapi-include-timing-metrics",
];
const HOP_BY_HOP_HEADERS = new Set([
  "connection", "keep-alive", "proxy-authenticate", "proxy-authorization",
  "te", "trailer", "transfer-encoding", "upgrade", "content-encoding",
]);

// Pipe an upstream body through to the client with the same resilience as the
// chat-completions path: SSE heartbeats, an idle watchdog, client-close abort,
// and a proper `error` event if the upstream dies mid-stream.
async function pipeNativeStream(upstreamRes, res, ctx) {
  const { reqId = "?", abortUpstream } = ctx;
  const tag = `#${reqId}`;
  const streamStart = Date.now();
  let lastByteAt = Date.now();
  let bytesIn = 0;
  let clientGone = false;
  let endReason = "upstream closed";

  const onClientClose = () => {
    if (res.writableEnded) return;
    clientGone = true;
    endReason = "client disconnected";
    log("NATIVE", `${tag} client disconnected mid-stream — aborting upstream`);
    if (abortUpstream) { try { abortUpstream(); } catch (e) {} }
  };
  res.on("close", onClientClose);

  const watchdog = setInterval(() => {
    const quietMs = Date.now() - lastByteAt;
    if (quietMs >= UPSTREAM_IDLE_MS) {
      endReason = `upstream idle ${Math.round(quietMs / 1000)}s (limit ${Math.round(UPSTREAM_IDLE_MS / 1000)}s)`;
      log("NATIVE", `${tag} ${endReason} — aborting upstream`);
      if (abortUpstream) { try { abortUpstream(); } catch (e) {} }
      return;
    }
    if (res.headersSent && quietMs >= HEARTBEAT_MS) {
      try { res.write(": keepalive\n\n"); } catch (e) {}
    }
  }, HEARTBEAT_MS);

  try {
    const reader = upstreamRes.body.getReader();
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      lastByteAt = Date.now();
      bytesIn += value.length || 0;
      if (res.destroyed || res.writableEnded) break;
      if (!res.write(Buffer.from(value))) {
        // Backpressure: wait for drain (abort upstream if the client is gone).
        await new Promise((resolve) => {
          if (res.destroyed || res.writableEnded) return resolve();
          res.once("drain", resolve);
        });
      }
    }
  } catch (err) {
    if (endReason === "upstream closed") {
      endReason = `upstream read error: ${err.message}`;
      log("NATIVE", `${tag} ${endReason}`);
    }
  } finally {
    clearInterval(watchdog);
    res.off("close", onClientClose);
  }

  if (clientGone) {
    log("NATIVE", `${tag} aborted after ${Date.now() - streamStart}ms | ${endReason} | bytesIn=${bytesIn}`);
    try { res.end(); } catch (e) {}
    return;
  }

  // Mid-stream upstream failure: end with a proper error event so Codex
  // surfaces it instead of a short, successful-looking turn.
  if (endReason.startsWith("upstream idle") || endReason.startsWith("upstream read error")) {
    log("NATIVE", `${tag} upstream failed mid-stream — sending error event | ${endReason} | bytesIn=${bytesIn}`);
    writeStreamErrorEvent(res, {
      code: "native_stream_failed",
      message: "ChatGPT lost the response stream mid-turn. Please try again.",
    });
    res.write("event: done\ndata: [DONE]\n\n");
    res.end();
    return;
  }

  log("NATIVE", `${tag} done in ${Date.now() - streamStart}ms | bytesIn=${bytesIn} | ${endReason}`);
  res.end();
}

// Forward a native Responses API request to chatgpt.com, copying the caller's
// ChatGPT session headers through. `nativePath` is the path under NATIVE_BASE
// (default "/responses"; the catch-all passes e.g. "/responses/compact").
// Derives the target from chatgpt_base_url in config (codex-router style),
// falling back to the hardcoded default. Uses the incoming Authorization header
// first; preserved side-file tokens are a fallback only.
async function handleNativePassthrough(req, res, model, reqId, nativePath = "/responses") {
  const tag = `#${reqId}`;

  // Derive native base from chatgpt_base_url (like codex-router's
  // nativeRealtimeCallBaseUrl), falling back to the default.
  const cfg = parseTopLevelValues(readConfigToml());
  const nativeBase = (cfg.chatgpt_base_url || "https://chatgpt.com/backend-api/codex").replace(/\/+$/, "");
  const target = `${nativeBase}${nativePath}`;

  // Prefer the incoming Authorization header (Codex sends this in native ChatGPT
  // mode). Fall back to preserved side-file tokens only when the header is absent.
  const incomingAuth = req.headers["authorization"];
  let authToken = null;
  let accountId = null;
  if (typeof incomingAuth === "string" && incomingAuth.startsWith("Bearer ")) {
    authToken = incomingAuth.slice(7);
  } else {
    const chatgpt = readChatGptTokens();
    if (chatgpt) { authToken = chatgpt.accessToken; accountId = chatgpt.accountId; }
  }
  if (!authToken) {
    log("NATIVE", `${tag} no auth available — cannot passthrough to ${target}`);
    return res.status(401).json({
      error: {
        message: "No ChatGPT session found. Log in to ChatGPT in the Codex app, then try again.",
        type: "auth_error",
      },
    });
  }

  const headers = {
    "Content-Type": "application/json",
    "Authorization": `Bearer ${authToken}`,
    "Accept-Encoding": "identity",
  };
  if (accountId) headers["chatgpt-account-id"] = accountId;
  for (const name of NATIVE_FORWARD_HEADERS) {
    if (name === "authorization") continue; // already set above
    const value = req.headers[name];
    if (value !== undefined) headers[name] = Array.isArray(value) ? value.join(", ") : value;
  }

  const controller = new AbortController();
  req.once("aborted", () => controller.abort());
  res.once("close", () => { if (!res.writableEnded) controller.abort(); });

  log("NATIVE", `${tag} -> ${target} | model=${model} | stream=${req.body?.stream !== false}`);
  let upstream;
  try {
    upstream = await fetch(target, {
      method: "POST",
      headers,
      body: JSON.stringify(req.body),
      signal: controller.signal,
    });
  } catch (err) {
    log("NATIVE", `${tag} fetch error: ${err.message}`);
    if (res.headersSent) {
      writeStreamErrorEvent(res, { code: "native_fetch_failed", message: "Failed to reach ChatGPT. Please try again." });
      try { res.end(); } catch (e) {}
    } else {
      res.status(502).json({ error: { message: `Failed to reach ChatGPT: ${err.message}` } });
    }
    return;
  }

  if (!upstream.ok) {
    const errText = await upstream.text();
    log("NATIVE", `${tag} upstream error ${upstream.status}: ${errText.slice(0, 300)}`);
    if (upstream.status === 401) {
      return res.status(401).json({
        error: { message: "ChatGPT session expired. Log in to ChatGPT in the Codex app, then try again.", type: "auth_error" },
      });
    }
    return res.status(upstream.status).send(errText);
  }

  // Pipe the Responses API stream through verbatim.
  res.status(upstream.status);
  for (const [k, v] of upstream.headers) {
    if (!HOP_BY_HOP_HEADERS.has(k.toLowerCase())) {
      try { res.setHeader(k, v); } catch (e) {}
    }
  }
  if (typeof res.flushHeaders === "function") res.flushHeaders();
  await pipeNativeStream(upstream, res, { reqId, abortUpstream: () => controller.abort() });
}

app.post("/v1/responses", async (req, res) => {
  // Short correlation id: Codex fires concurrent turns, and without a tag the
  // interleaved request/stream lines in the log cannot be matched up.
  const reqId = rid();
  const tag = `#${reqId}`;
  log("PROXY", `${tag} <- POST /v1/responses`);
  try {
    const root = req.body;

    // Route by model: a namespaced custom id → its provider (chat-completions
    // translation below); a native GPT model → ChatGPT passthrough.
    const requestedModel = root.model;
    const aliasTarget = readNativeAliases()[requestedModel];
    const route = resolveModelRoute(aliasTarget || requestedModel);
    if (!route) {
      return res.status(404).json({ error: `Unknown model: ${root.model}` });
    }
    if (route.type === "ambiguous") {
      const data = loadProviders();
      return res.status(409).json({
        error: `Model "${root.model}" is served by multiple providers. Pick a namespaced model, e.g. ${route.providers.map(p => `${providerKeyFor(p, data.providers)}/${root.model}`).join(" or ")}.`,
      });
    }
    if (route.type === "native" && !aliasTarget) {
      return handleNativePassthrough(req, res, route.modelId, reqId);
    }
    if (route.type === "native" && aliasTarget) {
      return res.status(500).json({ error: `Alias target is not a custom route: ${aliasTarget}` });
    }
    const provider = route.provider;
    const modelId = route.modelId;

    // Collect tool definitions. This Codex build delivers them inside an
    // "additional_tools" input item rather than the top-level `tools` field,
    // so we merge both sources.
    const collectedTools = [];
    if (Array.isArray(root.tools)) collectedTools.push(...root.tools);
    if (Array.isArray(root.input)) {
      for (const item of root.input) {
        if (item.type === "additional_tools" && Array.isArray(item.tools)) {
          collectedTools.push(...item.tools);
        }
      }
    }
    // Names of "custom" (grammar/freeform) tools. Chat Completions has no
    // grammar tools, so we expose them as functions taking a single string
    // "input" arg and map the model's reply back to a custom_tool_call on the
    // way out (see the tool_calls handling below).
    const customToolNames = new Set(
      collectedTools.filter(t => t.type === "custom" && t.name).map(t => t.name)
    );

    let messages = [];

    // Merge Codex's own instructions with our agent-behavior guidance so the
    // swapped model narrates and reads files instead of blindly running commands.
    const sysParts = [];
    if (root.instructions) sysParts.push(root.instructions);
    if (AGENT_GUIDANCE) sysParts.push(AGENT_GUIDANCE);
    if (sysParts.length) messages.push({ role: "system", content: sysParts.join("\n\n") });

    if (typeof root.input === "string") {
      messages.push({ role: "user", content: root.input });
    } else if (Array.isArray(root.input)) {
      // Group consecutive function_call items into a single assistant message with a
      // tool_calls array, which is the format chat completions expects.
      let pendingToolCalls = [];
      const flushToolCalls = () => {
        if (pendingToolCalls.length > 0) {
          messages.push({
            role: "assistant",
            content: null,
            tool_calls: pendingToolCalls,
          });
          pendingToolCalls = [];
        }
      };
      for (const item of root.input) {
        if (item.type === "additional_tools") {
          // Tool definitions, not conversation content — handled separately.
          continue;
        } else if (item.type === "function_call_output" || item.type === "custom_tool_call_output") {
          flushToolCalls();
          let out = item.output;
          if (out != null && typeof out !== "string") out = JSON.stringify(out);
          messages.push({ role: "tool", tool_call_id: item.call_id || "", content: out || "" });
        } else if (item.type === "function_call") {
          pendingToolCalls.push({
            id: item.call_id || item.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
            type: "function",
            function: { name: item.name || "", arguments: item.arguments || "{}" }
          });
        } else if (item.type === "custom_tool_call") {
          // Freeform custom-tool call in history -> a function tool_call whose
          // single "input" arg carries the freeform text.
          pendingToolCalls.push({
            id: item.call_id || item.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
            type: "function",
            function: { name: item.name || "", arguments: JSON.stringify({ input: item.input || "" }) }
          });
        } else {
          flushToolCalls();
          let role = item.role || "user";
          if (role === "developer") role = "system";
          let content = item.content || "";
          if (Array.isArray(content)) {
            content = content.map(p => p.text).join("\n");
          } else if (typeof content === "object" && content !== null) {
            content = content.text || "";
          }
          if (content) messages.push({ role, content });
        }
      }
      flushToolCalls();
    }

    // Codex always asks us for a stream; honor that toward the upstream too so
    // long turns keep flowing bytes instead of buffering until fully done.
    const wantStream = root.stream !== false;
    const chatBody = {
      model: modelId || root.model || "mimo-v2.5-pro-free",
      messages: messages,
      stream: wantStream,
    };
    // Codex App sends effort per request. Preserve that value for providers
    // that support reasoning; fall back to the dashboard's root setting.
    const requestedEffort = root.reasoning?.effort || root.reasoning_effort || parseTopLevelValues(readConfigToml()).model_reasoning_effort;
    if (requestedEffort) chatBody.reasoning_effort = requestedEffort;
    if (wantStream) chatBody.stream_options = { include_usage: true };
    if (root.temperature !== undefined) chatBody.temperature = root.temperature;
    if (root.max_output_tokens !== undefined) chatBody.max_tokens = root.max_output_tokens;
    
    if (collectedTools.length) {
      let tools = [];
      for (const t of collectedTools) {
        if (t.type === "function") {
          if (t.function) {
            tools.push({ type: "function", function: t.function });
          } else {
            tools.push({
              type: "function",
              function: {
                name: t.name || "",
                description: t.description || "",
                parameters: t.parameters || { type: "object", properties: {} }
              }
            });
          }
        } else if (t.type === "custom") {
          // Grammar/freeform custom tool (e.g. "exec") -> a plain function that
          // takes the whole tool body as a single string "input" arg, since
          // Chat Completions cannot enforce grammars.
          let desc = t.description || "";
          desc += "\n\n(Provide the full tool input/source as a single string in the \"input\" field.)";
          tools.push({
            type: "function",
            function: {
              name: t.name || "",
              description: desc,
              parameters: {
                type: "object",
                properties: { input: { type: "string", description: "The full tool input/source as text." } },
                required: ["input"]
              }
            }
          });
        }
        // Other builtin tool types (web_search, etc.) can't be serviced by a
        // generic chat-completions provider, so they are skipped.
      }
      if (tools.length > 0) chatBody.tools = tools;
    }
    if (root.tool_choice) chatBody.tool_choice = root.tool_choice;

    let targetUrl = provider.baseUrl.replace(/\/+$/, "");
    let completionUrl = targetUrl;
    if (completionUrl.endsWith("/chat/completions")) {
      // do nothing
    } else if (completionUrl.endsWith("/chat")) {
      completionUrl += "/completions";
    } else {
      completionUrl += "/chat/completions";
    }

    // Pace the request with the token bucket, then send it upstream. We retry
    // on two classes of transient failure: (a) 429/5xx HTTP status, and (b) a
    // 200 OK response with an empty body (no text, no tool calls) — a degenerate
    // response some providers emit under load. Like OpenRouter, we retry empty
    // responses instead of silently handing Codex a turn with nothing to show.
    let upstreamAbort;
    let fetchRes = null;
    let attempt = 0;          // 429/5xx retry count
    let backoff = UPSTREAM_RETRY_BASE_MS;
    let emptyAttempt = 0;     // empty-response retry count
    const fallbackModel = modelId || root.model || "unknown";

    while (true) {
      await bucketFor(provider).take();
      upstreamAbort = new AbortController();
      fetchRes = await fetch(completionUrl, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          ...(wantStream ? { "Accept": "text/event-stream" } : {}),
          ...(provider.apiKey ? { "Authorization": `Bearer ${provider.apiKey}` } : {})
        },
        body: JSON.stringify(chatBody),
        signal: upstreamAbort.signal
      });

      const toolNames = (chatBody.tools || []).map(t => t.function?.name || t.name || "?").join(",");
      log("PROXY", `${tag} -> ${completionUrl} | model=${chatBody.model} msgs=${messages.length} tools=[${toolNames}] stream=${wantStream} | upstream ${fetchRes.status}${attempt ? ` (retry ${attempt})` : ""}${emptyAttempt ? ` (empty-retry ${emptyAttempt})` : ""}`);

      if (!fetchRes.ok) {
        const errText = await fetchRes.text();
        log("PROXY", `${tag} upstream error ${fetchRes.status}: ${errText.slice(0, 300)}`);
        if (!isRetryableStatus(fetchRes.status) || attempt >= UPSTREAM_RETRY_MAX) {
          return res.status(502).send(errText);
        }
        attempt++;
        // In auto mode, learn the provider's real limit from the 429 headers and
        // honor Retry-After so we don't hammer it again while it recovers.
        const bucket = bucketFor(provider);
        const waitMs = bucket.applyRateLimit(Object.fromEntries(fetchRes.headers.entries()));
        const delay = waitMs != null ? Math.min(waitMs, UPSTREAM_RETRY_MAX_MS) : backoff;
        log("PROXY", `${tag} retrying in ${delay}ms (attempt ${attempt}/${UPSTREAM_RETRY_MAX})${waitMs != null ? " (honoring Retry-After)" : ""}`);
        await new Promise((r) => setTimeout(r, delay));
        backoff = Math.min(backoff * 2, UPSTREAM_RETRY_MAX_MS);
        continue; // re-fetch
      }

      // ── OK response: dispatch to the right path ───────────────────────────
      const upstreamCT = fetchRes.headers.get("content-type") || "";
      const upstreamIsSSE = upstreamCT.includes("text/event-stream");

      // ── Path A: true streaming passthrough ────────────────────────────────
      // Upstream honored our stream request → translate deltas live so Codex
      // keeps receiving bytes and never trips its idle timeout. The stream uses
      // delayed commit (no response.created until first real content), so an
      // empty upstream stream can be retried by the caller.
      if (wantStream && upstreamIsSSE && fetchRes.body) {
        log("PROXY", `${tag} Path A: true streaming passthrough (upstream CT="${upstreamCT}")${emptyAttempt ? ` (empty-retry ${emptyAttempt})` : ""}`);
        const streamRes = await streamUpstreamToResponses(fetchRes, res, {
          customToolNames,
          fallbackModel,
          reqId,
          abortUpstream: () => upstreamAbort.abort()
        });
        // If the stream produced content, we're done. If it came back empty
        // (never committed), retry the whole request — the upstream gave us a
        // degenerate 200 OK with no content.
        if (streamRes && streamRes.empty) {
          emptyAttempt++;
          if (emptyAttempt > UPSTREAM_EMPTY_RETRY_MAX) {
            log("PROXY", `${tag} empty response after ${emptyAttempt} attempts — sending visible error to Codex`);
            sendEmptyCompletionError(res, "upstream_empty_response", "⚠️ Upstream provider returned an empty response after multiple retries. Please try again.");
            break;
          }
          log("PROXY", `${tag} empty stream — retrying (attempt ${emptyAttempt}/${UPSTREAM_EMPTY_RETRY_MAX})`);
          continue; // re-fetch
        }
        break; // done (normal completion or client gone)
      }

      // ── Path B/C: non-streaming (upstream ignored stream or we didn't ask) ─
      const chatResponse = await fetchRes.json();
      const choice = chatResponse.choices && chatResponse.choices[0];
      const message = choice ? choice.message : {};
      const output = chatMessageToOutputItems(message, customToolNames);
      // Always report the model the user configured (chatBody.model), not the
      // upstream's internal model id, so Codex displays the expected name.
      const responseBody = buildResponseBody(output, chatBody.model, chatResponse.usage);

      // Empty-response check: retry a degenerate non-streaming response too.
      if (output.length === 0) {
        emptyAttempt++;
        if (emptyAttempt > UPSTREAM_EMPTY_RETRY_MAX) {
          log("PROXY", `${tag} empty non-streaming response after ${emptyAttempt} attempts — sending visible error`);
          if (wantStream) {
            sendEmptyCompletionError(res, "upstream_empty_response", "⚠️ Upstream provider returned an empty response after multiple retries. Please try again.");
          } else {
            res.status(502).json({ error: { message: "Upstream provider returned an empty response after retries", type: "empty_response" } });
          }
          break;
        }
        log("PROXY", `${tag} empty non-streaming response — retrying (attempt ${emptyAttempt}/${UPSTREAM_EMPTY_RETRY_MAX})`);
        continue; // re-fetch
      }

      // ── Path B: Codex wants a stream, upstream gave us one JSON blob ───────
      // Replay the complete answer as SSE events (buffered fallback).
      if (wantStream) {
        log("PROXY", `${tag} Path B: buffered fallback (upstream not SSE, CT="${upstreamCT}") | items=${output.length}`);
        res.setHeader("Content-Type", "text/event-stream");
        res.setHeader("Cache-Control", "no-cache");
        res.setHeader("Connection", "keep-alive");
        if (typeof res.flushHeaders === "function") res.flushHeaders();
        const sendSSE = (event, dataObj) => res.write(`event: ${event}\ndata: ${JSON.stringify(dataObj)}\n\n`);
        sendSSE("response.created", { type: "response.created", response: responseBody });
        for (let i = 0; i < output.length; i++) emitItemEvents(sendSSE, output[i], i);
        sendSSE("response.completed", { type: "response.completed", response: responseBody });
        res.write("event: done\ndata: [DONE]\n\n");
        res.end();
        break;
      }

      // ── Path C: plain non-streaming JSON ──────────────────────────────────
      log("PROXY", `${tag} Path C: plain JSON | items=${output.length}`);
      res.json(responseBody);
      break;
    }

  } catch (err) {
    log("PROXY", `${tag} ERROR: ${err.message}`);
    if (res.headersSent) {
      // The stream is already committed — end it with a proper error event so
      // Codex surfaces the failure instead of a short, successful-looking turn.
      writeStreamErrorEvent(res, {
        code: "proxy_stream_failed",
        message: "The local proxy failed mid-stream. Please try again.",
      });
      try { res.end(); } catch (e) {}
    } else {
      res.status(500).json({ error: err.message });
    }
  }
});

app.use("/v1", (req, res, next) => {
  // Route by model: custom provider models → that provider; native GPT models →
  // ChatGPT. This covers paths the dedicated /v1/responses handler doesn't
  // (e.g. /v1/responses/compact, /v1/chat/completions).
  const model = req.body && req.body.model;
  const aliasTarget = model ? readNativeAliases()[model] : null;
  const route = model ? resolveModelRoute(aliasTarget || model) : null;

  // Codex/desktop may probe this base with a GET that has no model. Do not
  // misreport that harmless capability probe as "Unknown model: (none)".
  if (!model && req.method === "GET") {
    // Desktop capability probes GET /v1/responses without a body. Treat it as
    // a harmless probe instead of returning the misleading Unknown model error.
    return res.status(200).json({ object: "endpoint", supported: true });
  }
  if (!model && req.method !== "POST") {
    return res.status(405).json({ error: "This endpoint requires a POST request with a model." });
  }

  // Native passthrough for any /v1/* path (compact, etc.).
  if (route && route.type === "native" && !aliasTarget) {
    const nativePath = req.path.replace(/^\/v1(?=\/|$)/, "");
    return handleNativePassthrough(req, res, route.modelId, rid(), nativePath || "/responses");
  }

  if (route && route.type === "ambiguous") {
    const data = loadProviders();
    return res.status(409).json({
      error: `Model "${model}" is served by multiple providers. Pick a namespaced model, e.g. ${route.providers.map(p => `${providerKeyFor(p, data.providers)}/${model}`).join(" or ")}.`,
    });
  }

  const provider = route && route.type === "custom" ? route.provider : null;
  if (!provider || !provider.baseUrl) {
    return res.status(400).json({ error: `Unknown model: ${model || "(none)"}` });
  }

  // Compact is a Responses-API-only endpoint; chat-completions providers don't
  // have it (native compact is handled by the passthrough above).
  if (req.path.endsWith("/compact")) {
    return res.status(501).json({ error: "Context compaction is not supported by custom chat-completions providers." });
  }

  // Remove /v1 suffix from provider.baseUrl since the proxy will append the request path (e.g. /v1/chat/completions)
  let targetUrl = provider.baseUrl;
  if (targetUrl.endsWith('/v1')) {
    targetUrl = targetUrl.slice(0, -3);
  } else if (targetUrl.endsWith('/v1/')) {
    targetUrl = targetUrl.slice(0, -4);
  }
  
  return createProxyMiddleware({
    target: targetUrl,
    changeOrigin: true,
    on: {
      proxyReq: (proxyReq, req, res) => {
        if (provider.apiKey) {
          proxyReq.setHeader('Authorization', `Bearer ${provider.apiKey}`);
        }
        proxyReq.setHeader('HTTP-Referer', 'http://localhost:3777');
        proxyReq.setHeader('X-Title', 'Codex Model Switcher Local Proxy');

        // Rewrite model in the JSON body so the custom provider gets the real model name
        if (req.body && route.modelId && req.method === "POST") {
          req.body.model = route.modelId;
          fixRequestBody(proxyReq, req);
        }
      }
    }
  })(req, res, next);
});

// ── Start ────────────────────────────────────────────────────────────────────

// ── Keep injected models in the picker ─────────────────────────────────────
// Codex rewrites `models_cache.json` on launch / refresh, which wipes our
// injected entries and makes the provider models vanish from the picker. To
// survive that, we (a) re-inject every enabled provider's models at startup,
// and (b) watch the cache file and re-inject whenever Codex overwrites it.
//
// The watcher is self-stabilizing: it only writes when one of the expected
// injected slugs is *missing* from the cache, so our own write (which adds
// them) does not trigger another write — no infinite loop.
//
// Both paths only act while passthrough is actually enabled (config.toml has
// `model_provider = "customProvider"`); otherwise we clean up instead, so a
// disabled passthrough never gets re-injected behind the user's back.
function managedBlockActive() {
  try {
    const raw = readConfigToml();
    return raw.includes(MANAGED_START) && raw.includes(MANAGED_END);
  } catch { return false; }
}

function passthroughActive() {
  try {
    const cfg = parseTopLevelValues(readConfigToml());
    return managedBlockActive() || Boolean(cfg.openai_base_url);
  } catch (e) {
    return false;
  }
}

function reInjectAllProviders() {
  try {
    if (!passthroughActive()) {
      // Passthrough off: make sure nothing of ours lingers in the picker.
      ejectProviderModels();
      try { if (fs.existsSync(MERGED_CATALOG_PATH)) fs.unlinkSync(MERGED_CATALOG_PATH); } catch (e) {}
      return;
    }
    const data = loadProviders();
    const enabled = data.providers.filter((p) => p.enabled !== false);
    if (enabled.length === 0) {
      ejectProviderModels();
      return;
    }
    injectAllProviders();
  } catch (err) {
    log("CACHE", `re-inject failed: ${err.message}`);
  }
}

// Re-inject once at startup so the picker is correct before the user opens Codex.
reInjectAllProviders();

// Watch for Codex overwriting the cache, and re-inject after a short debounce.
let cacheWatchTimer = null;
let cacheWatchBusy = false;
try {
  if (fs.existsSync(CODEX_DIR)) {
    fs.watch(CODEX_DIR, (eventType, filename) => {
      if (filename !== "models_cache.json") return;
      if (cacheWatchBusy) return;
      if (cacheWatchTimer) clearTimeout(cacheWatchTimer);
      cacheWatchTimer = setTimeout(() => {
        cacheWatchBusy = true;
        try {
          if (!passthroughActive()) return; // nothing should be injected
          const data = loadProviders();
          const enabled = data.providers.filter((p) => p.enabled !== false);
          if (enabled.length === 0) return;
          // Only re-inject if one of our expected slugs is actually missing.
          const expected = [];
          for (const provider of enabled) {
            const key = providerKeyFor(provider, data.providers);
            for (const id of (provider.models || [])) {
              if (id) expected.push(`${key}/${id}`);
            }
          }
          const { data: cache } = readModelsCache();
          const present = new Set(
            (cache && Array.isArray(cache.models) ? cache.models : [])
              .filter(m => m && m[INJECTED_TAG] === true)
              .map(m => m.slug)
          );
          if (expected.some(slug => !present.has(slug))) {
            injectAllProviders();
            log("CACHE", "re-injected provider models after Codex rewrite");
          }
        } catch (err) {
          log("CACHE", `watch re-inject failed: ${err.message}`);
        } finally {
          cacheWatchBusy = false;
        }
      }, 600);
    });
  }
} catch (err) {
  log("CACHE", `file watcher unavailable: ${err.message}`);
}

const server = app.listen(PORT, () => {
  console.log("");
  console.log("  ╔══════════════════════════════════════════╗");
  console.log("  ║   🚀 Codex Model Switcher is running!   ║");
  console.log("  ╠══════════════════════════════════════════╣");
  console.log(`  ║   http://localhost:${PORT}                 ║`);
  console.log("  ╚══════════════════════════════════════════╝");
  console.log("");
  console.log(`  Config: ${maskUserPath(CONFIG_PATH)}`);
  console.log("");
});

server.on("error", (err) => {
  if (err.code === "EADDRINUSE") {
    console.error("");
    console.error(`  ⚠  Port ${PORT} is already in use.`);
    console.error("");
    console.error("  Codex Switcher is probably already running in another window,");
    console.error(`  so just open  http://localhost:${PORT}  in your browser.`);
    console.error("");
    console.error("  If it's NOT already running, another program is using the port.");
    console.error("  Free it with (PowerShell):");
    console.error(`      Get-NetTCPConnection -LocalPort ${PORT} | Stop-Process -Id { $_.OwningProcess } -Force`);
    console.error("");
  } else {
    console.error("");
    console.error(`  ⚠  Server failed to start: ${err.message}`);
    console.error("");
  }
  process.exit(1);
});