server.js

const http = require("node:http");
const { URL } = require("node:url");
const fs = require("node:fs");
const fsp = require("node:fs/promises");
const path = require("node:path");
const crypto = require("node:crypto");
const { Readable } = require("node:stream");

function isEnvOn(name) {
  return /^(1|true|yes|on)$/i.test(String(process.env[name] || ""));
}

const CONFIG = {
  port: Number(process.env.PORT || 8787),
  host: process.env.HOST || "0.0.0.0",
  apiKey: process.env.API_KEY || "change-me",
  dataDir: process.env.DATA_DIR || path.join(__dirname, "data"),
  accountsFile: process.env.ACCOUNTS_FILE || path.join(__dirname, "data", "accounts.json"),
  maxRequestBodyBytes: Number(process.env.MAX_REQUEST_BODY_BYTES || 20 * 1024 * 1024),
  maxUploadBytes: Number(process.env.MAX_UPLOAD_BYTES || 25 * 1024 * 1024),
  // 图片上传后是否等待 file_processing_queue 入库完成；默认不等待（0），更贴近官方前端的“异步处理 + 轮询状态”体验
  // 经过多次测试推荐20s，设为默认
  imageProcessingWaitMs: Number(process.env.IMAGE_PROCESSING_WAIT_MS || 20 * 1000),
  imageProcessingPollIntervalMs: Number(process.env.IMAGE_PROCESSING_POLL_INTERVAL_MS || 750),

  supabaseBase: "https://db.zerotwo.ai",
  // 你确认这是“公开 anon key”，可写死；如需替换，可用环境变量覆盖。
  supabaseAnonKey:
    process.env.SUPABASE_ANON_KEY ||
    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpkYmNldmpicWFveHJ4eHdxd3V4Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTgyNDcyMzUsImV4cCI6MjA3MzgyMzIzNX0.UcUJUjMocwijFTtYFKYuTgIODYWc4uxDByu2tI6XGQg",

  zerotwoApiBase: process.env.ZEROTWO_API_BASE || "https://api.zerotwo.ai",
  zerotwoOrigin: process.env.ZEROTWO_ORIGIN || "https://app.zerotwo.ai",

  // 高并发下抖动控制：提前刷新 + 单飞互斥 + 熔断退避
  accessRefreshLeewayMs: 20 * 60 * 1000,
  csrfRefreshLeewayMs: 60 * 60 * 1000,
  // 当触发“authentication rate limit”时，Security 刷新冷却时间（避免 20s 频率加重限流）
  auth429SecurityCooldownMs: 10 * 60 * 1000,
  auth429SecurityCooldownJitterMinMs: 5 * 1000,
  auth429SecurityCooldownJitterMaxMs: 30 * 1000,
  backgroundTickMs: 20 * 1000,
  // 后台刷新节流：每轮最多处理 4 个账号、并发最多 2
  backgroundGroupSize: 4,
  backgroundMaxConcurrent: 2,

  // 账号级并发上限（可在网页里对单账号覆盖）
  defaultMaxInflightPerAccount: 8,

  // 请求超时
  httpTimeoutMs: 60 * 1000,

  // Debug 开关（默认关闭）
  debugMode: isEnvOn("DEBUG_MODE") || isEnvOn("DEBUG_RAW_STREAM"),
  debugRawStream: isEnvOn("DEBUG_RAW_STREAM") || isEnvOn("DEBUG_MODE"),
  debugLogMaxChars: Number(process.env.DEBUG_LOG_MAX_CHARS || 4000)
};

const ANTHROPIC_THINKING_BUDGETS = [1024, 4096, 10000, 16000];
const IMAGE_MODEL_IDS = [
  "gpt-image-1.5",
  "gpt-image-1",
  "gpt-image-1-mini",
  "imagen-4.0-generate-preview-06-06",
  "nano-banana-pro"
];
const IMAGE_EDIT_MODEL_IDS = IMAGE_MODEL_IDS;
const DEFAULT_IMAGE_MODEL_ON_IMPORT = "nano-banana-pro";

function nowMs() {
  return Date.now();
}

function clipForLog(value, maxChars = CONFIG.debugLogMaxChars) {
  let s = "";
  if (typeof value === "string") s = value;
  else {
    try {
      s = JSON.stringify(value);
    } catch (e) {
      s = String(value ?? e ?? "");
    }
  }
  if (!s) return "";
  const limit = Number(maxChars || 0);
  if (!Number.isFinite(limit) || limit <= 0) return s;
  if (s.length <= limit) return s;
  return `${s.slice(0, limit)}...<truncated ${s.length - limit} chars>`;
}

function debugLog(tag, payload) {
  if (!CONFIG.debugMode) return;
  const ts = new Date().toISOString();
  if (payload === undefined) {
    console.log(`[debug][${ts}][${tag}]`);
    return;
  }
  const line = typeof payload === "string" ? payload : JSON.stringify(payload);
  console.log(`[debug][${ts}][${tag}] ${clipForLog(line)}`);
}

function sha256Base64Url(input) {
  return crypto.createHash("sha256").update(input).digest("base64url");
}

function randIntInclusive(min, max) {
  const a = Math.ceil(Number(min));
  const b = Math.floor(Number(max));
  if (!Number.isFinite(a) || !Number.isFinite(b)) return 0;
  if (b <= a) return a;
  return a + Math.floor(Math.random() * (b - a + 1));
}

function safeJsonParse(text) {
  try {
    return { ok: true, value: JSON.parse(text) };
  } catch (e) {
    return { ok: false, error: String(e) };
  }
}

function parseJwtPayload(token) {
  const t = typeof token === "string" ? token.trim() : "";
  if (!t) return null;
  const parts = t.split(".");
  if (parts.length < 2) return null;
  try {
    const json = Buffer.from(parts[1], "base64url").toString("utf8");
    const parsed = safeJsonParse(json);
    return parsed.ok ? parsed.value : null;
  } catch {
    return null;
  }
}

function csrfCookieFromSecurity(security) {
  const rawCookie = typeof security?.csrfCookie === "string" ? security.csrfCookie.trim() : "";
  if (rawCookie) return rawCookie;
  const token = typeof security?.csrfToken === "string" ? security.csrfToken.trim() : "";
  return token ? `__csrf=${token}` : "";
}

function extractCsrfCookieFromSetCookie(rawSetCookie) {
  const raw = typeof rawSetCookie === "string" ? rawSetCookie : "";
  if (!raw) return "";
  const m = raw.match(/(?:^|,\s*)__csrf=([^;,\s]+)/);
  return m ? `__csrf=${m[1]}` : "";
}

function extractCsrfCookieFromHeaders(headers) {
  if (!headers) return "";
  if (typeof headers.getSetCookie === "function") {
    const setCookies = headers.getSetCookie();
    if (Array.isArray(setCookies)) {
      for (const item of setCookies) {
        const cookie = extractCsrfCookieFromSetCookie(item);
        if (cookie) return cookie;
      }
    }
  }
  if (typeof headers.get === "function") {
    return extractCsrfCookieFromSetCookie(headers.get("set-cookie") || "");
  }
  return "";
}

function randomId(prefix) {
  return `${prefix}_${crypto.randomBytes(12).toString("hex")}`;
}

function normalizeProviderName(provider) {
  const p = String(provider || "").trim();
  if (!p) return "openai";
  const lower = p.toLowerCase();
  // 兼容用户口误
  if (lower === "authropic") return "anthropic";
  return lower;
}

function parseProviderModelFromOpenAIRequest(openaiReq) {
  const requestedModelRaw = typeof openaiReq?.model === "string" ? openaiReq.model.trim() : "";
  let provider = typeof openaiReq?.provider === "string" ? openaiReq.provider.trim() : "openai";
  let model = requestedModelRaw || "gpt-5.2";
  if (requestedModelRaw.includes("/")) {
    const [p, ...rest] = requestedModelRaw.split("/");
    // 只取第一个分段作为 provider，其余原样拼回作为 model
    if (p) provider = p;
    if (rest.length) model = rest.join("/");
  }
  provider = normalizeProviderName(provider);
  return { provider, model };
}

function extractTextFromMessageContent(content) {
  if (typeof content === "string") return content;
  if (!Array.isArray(content)) return "";

  let text = "";

  for (const part of content) {
    if (!part || typeof part !== "object") continue;
    const type = String(part.type || "").toLowerCase();

    if (type === "text" || type === "input_text") {
      const t = typeof part.text === "string" ? part.text : typeof part.content === "string" ? part.content : "";
      if (t) text += (text ? "\n" : "") + t;
      continue;
    }
  }

  return text;
}

function nearestAllowedNumber(value, allowed) {
  const v = Number(value);
  if (!Number.isFinite(v)) return null;
  let best = allowed[0];
  let bestDiff = Math.abs(v - best);
  for (const a of allowed) {
    const diff = Math.abs(v - a);
    if (diff < bestDiff) {
      best = a;
      bestDiff = diff;
    }
  }
  return best;
}

function budgetFromReasoningEffort(effort) {
  const e = String(effort ?? "").toLowerCase();
  if (e === "none" || e === "off" || e === "disabled") return null;
  if (e === "low" || e === "minimal") return 1024;
  if (e === "medium") return 4096;
  return 16000; // high / 默认
}

function normalizeAnthropicReasoningEffort(value) {
  if (value === null || value === undefined) return 16000;

  if (typeof value === "number") {
    if (!Number.isFinite(value) || value <= 0) return "off";
    return nearestAllowedNumber(value, ANTHROPIC_THINKING_BUDGETS) || 16000;
  }

  if (typeof value === "string") {
    const s = value.trim();
    const lower = s.toLowerCase();
    if (!lower) return 16000;
    if (lower === "off" || lower === "none" || lower === "disabled") return "off";

    // 允许用户用字符串直接写预算数字：例如 "4096"
    if (/^\d+$/.test(lower)) {
      const n = Number(lower);
      if (!Number.isFinite(n) || n <= 0) return "off";
      return nearestAllowedNumber(n, ANTHROPIC_THINKING_BUDGETS) || 16000;
    }

    const mapped = budgetFromReasoningEffort(lower);
    if (!mapped) return "off";
    return nearestAllowedNumber(mapped, ANTHROPIC_THINKING_BUDGETS) || 16000;
  }

  return 16000;
}

function normalizeAnthropicThinkingToReasoningEffort(inputThinking, fallbackEffort) {
  const raw = inputThinking && typeof inputThinking === "object" ? inputThinking : null;
  const rawType = raw?.type;
  const type = typeof rawType === "string" ? rawType.toLowerCase() : "";
  if (type === "off" || type === "disabled" || type === "none") {
    return "off";
  }

  const requestedBudget = raw?.budget_tokens ?? raw?.budgetTokens;
  return normalizeAnthropicReasoningEffort(requestedBudget ?? fallbackEffort);
}

function requireApiKey(req) {
  const headerKey = req.headers["x-api-key"];
  if (typeof headerKey === "string" && headerKey === CONFIG.apiKey) return true;

  const auth = req.headers.authorization;
  if (typeof auth === "string" && auth.startsWith("Bearer ")) {
    const token = auth.slice("Bearer ".length).trim();
    if (token === CONFIG.apiKey) return true;
  }

  return false;
}

async function supabaseRestJson(account, pathAndQuery, { method, body, headers } = {}) {
  const url = `${CONFIG.supabaseBase}${pathAndQuery}`;
  const doOnce = async () => {
    const ac = new AbortController();
    const t = setTimeout(() => ac.abort(), CONFIG.httpTimeoutMs);
    try {
      const res = await fetch(url, {
        method: method || "GET",
        headers: {
          accept: "application/json",
          apikey: CONFIG.supabaseAnonKey,
          authorization: `Bearer ${account.accessToken}`,
          "content-type": "application/json",
          ...(headers || {})
        },
        body: body === undefined ? undefined : JSON.stringify(body),
        signal: ac.signal
      });
      const text = await res.text();
      const parsed = safeJsonParse(text);
      return { ok: res.ok, status: res.status, json: parsed.ok ? parsed.value : null, text };
    } finally {
      clearTimeout(t);
    }
  };

  let r = await doOnce();
  if (r.status === 401 || r.status === 403) {
    await refreshSupabaseSession(account);
    r = await doOnce();
  }
  if (!r.ok) throw new Error(`Supabase REST 失败: ${r.status} ${r.text.slice(0, 200)}`);
  return r.json;
}

async function supabasePublicJson(account, pathAndQuery, { method, body, headers } = {}) {
  return await supabaseRestJson(account, pathAndQuery, {
    method,
    body,
    headers: {
      "content-profile": "public",
      "accept-profile": "public",
      ...(headers || {})
    }
  });
}

function sendJson(res, statusCode, body) {
  const payload = JSON.stringify(body);
  res.writeHead(statusCode, {
    "content-type": "application/json; charset=utf-8",
    "content-length": Buffer.byteLength(payload)
  });
  res.end(payload);
}

function sendText(res, statusCode, text, headers = {}) {
  res.writeHead(statusCode, {
    "content-type": "text/plain; charset=utf-8",
    ...headers
  });
  res.end(text);
}

async function readBody(req, limitBytes = 2 * 1024 * 1024) {
  return new Promise((resolve, reject) => {
    let total = 0;
    const chunks = [];
    req.on("data", (c) => {
      total += c.length;
      if (total > limitBytes) {
        reject(new Error("请求体过大"));
        req.destroy();
        return;
      }
      chunks.push(c);
    });
    req.on("end", () => resolve(Buffer.concat(chunks)));
    req.on("error", reject);
  });
}

function parseDataUrl(dataUrl) {
  const raw = typeof dataUrl === "string" ? dataUrl : "";
  if (!raw.startsWith("data:")) return null;
  const m = raw.match(/^data:([^;,]+)?(;base64)?,([\s\S]*)$/);
  if (!m) return null;
  const contentType = (m[1] || "application/octet-stream").trim();
  const isBase64 = Boolean(m[2]);
  const payload = m[3] || "";
  try {
    const buf = isBase64 ? Buffer.from(payload, "base64") : Buffer.from(decodeURIComponent(payload), "utf8");
    return { contentType, buffer: buf };
  } catch {
    return null;
  }
}

function extFromContentType(contentType) {
  const ct = String(contentType || "").toLowerCase();
  if (ct === "image/png") return ".png";
  if (ct === "image/jpeg") return ".jpg";
  if (ct === "image/webp") return ".webp";
  if (ct === "image/gif") return ".gif";
  return "";
}

function sanitizeFilename(name) {
  const raw = String(name || "").trim() || "upload";
  const safe = raw.replace(/[^\w.\-]+/g, "_").slice(0, 120);
  return safe || "upload";
}

function extractImageUrlsFromMessageContent(content) {
  if (!Array.isArray(content)) return [];
  const out = [];
  for (const part of content) {
    if (!part || typeof part !== "object") continue;
    const type = String(part.type || "").toLowerCase();
    if (type !== "image_url" && type !== "input_image" && type !== "image") continue;

    const candidate =
      (typeof part.image_url === "string" ? part.image_url : "") ||
      (typeof part.url === "string" ? part.url : "") ||
      (typeof part.image === "string" ? part.image : "") ||
      (typeof part.image_url?.url === "string" ? part.image_url.url : "") ||
      (typeof part.image_url?.uri === "string" ? part.image_url.uri : "") ||
      (typeof part.image?.url === "string" ? part.image.url : "") ||
      "";
    const url = candidate.trim();
    if (url) out.push(url);
  }
  return out;
}

function extractImageUrlsFromOpenAIRequest(openaiReq) {
  const msgs = Array.isArray(openaiReq?.messages) ? openaiReq.messages : [];
  const out = [];
  for (const m of msgs) {
    if (!m || typeof m !== "object") continue;
    out.push(...extractImageUrlsFromMessageContent(m.content));
  }
  return out;
}

function createBadAttachmentsError(message) {
  const err = new Error(message);
  err.code = "BAD_ATTACHMENTS";
  return err;
}

function createBadImageModelError(message) {
  const err = new Error(message);
  err.code = "BAD_IMAGE_MODEL";
  return err;
}

async function fetchBuffer(url, { timeoutMs, maxBytes } = {}) {
  const ac = new AbortController();
  const t = setTimeout(() => ac.abort(), Number(timeoutMs || CONFIG.httpTimeoutMs));
  try {
    const res = await fetch(url, { method: "GET", signal: ac.signal });
    if (!res.ok) throw new Error(`下载失败: ${res.status}`);
    const ab = await res.arrayBuffer();
    const buf = Buffer.from(ab);
    const limit = Number(maxBytes || 0) || 0;
    if (limit > 0 && buf.length > limit) throw new Error("文件过大");
    const ct = res.headers.get("content-type") || "";
    return { buffer: buf, contentType: ct };
  } finally {
    clearTimeout(t);
  }
}

async function resolveImageToUploadBytes(imageUrl) {
  const url = typeof imageUrl === "string" ? imageUrl.trim() : "";
  if (!url) throw createBadAttachmentsError("图片 URL 为空");
  const parsed = parseDataUrl(url);
  if (parsed) {
    if (parsed.buffer.length > CONFIG.maxUploadBytes) throw createBadAttachmentsError("图片过大");
    return { buffer: parsed.buffer, contentType: parsed.contentType || "application/octet-stream" };
  }
  // 允许 http(s) 外链：用于 image_url.url = https://...
  if (!/^https?:\/\//i.test(url)) {
    throw createBadAttachmentsError("仅支持 data: 或 http(s) 图片 URL");
  }
  try {
    const r = await fetchBuffer(url, { timeoutMs: CONFIG.httpTimeoutMs, maxBytes: CONFIG.maxUploadBytes });
    return { buffer: r.buffer, contentType: r.contentType || "application/octet-stream" };
  } catch (e) {
    throw createBadAttachmentsError(`图片下载失败: ${String(e?.message || e)}`);
  }
}

async function ensureThreadExists(account, threadId, { provider } = {}) {
  const sel = encodeURIComponent("id,vector_store_id,rag_enabled");
  const arr = await supabasePublicJson(account, `/rest/v1/threads?id=eq.${threadId}&select=${sel}`, { method: "GET" });
  const row = Array.isArray(arr) ? arr[0] : null;
  if (row?.id) return row;

  const nowIso = new Date().toISOString();
  // 对齐官方前端：创建 thread 记录，避免后续 vector store / upload 依赖 thread 不存在。
  const created = await supabasePublicJson(account, "/rest/v1/threads?select=*", {
    method: "POST",
    headers: {
      accept: "application/vnd.pgrst.object+json",
      prefer: "return=representation"
    },
    body: {
      id: threadId,
      title: "New Chat",
      user_id: account.userId || account.id,
      project_id: null,
      metadata: { project_id: null, needs_title_generation: false },
      created_at: nowIso,
      updated_at: nowIso,
      last_activity: nowIso,
      provider: normalizeProviderName(provider || "openai"),
      is_team: false,
      is_shared: false
    }
  });
  return created || { id: threadId, vector_store_id: null, rag_enabled: false };
}

async function ensureThreadVectorStore(account, threadId, { provider } = {}) {
  const row = await ensureThreadExists(account, threadId, { provider });
  const existing = typeof row?.vector_store_id === "string" ? row.vector_store_id : "";
  if (existing) return existing;

  const userId = account.userId || account.id;
  const rpcRes = await supabasePublicJson(account, "/rest/v1/rpc/create_vector_store", {
    method: "POST",
    body: {
      p_user_id: userId,
      p_thread_id: threadId,
      p_project_id: null,
      p_name: `Thread: ${String(row?.title || "New Chat")}`,
      p_description: `Vector store for thread ${threadId}`
    }
  });
  const first = Array.isArray(rpcRes) ? rpcRes[0] : null;
  const vectorStoreId = typeof first?.id === "string" ? first.id : "";
  if (!vectorStoreId) throw new Error("create_vector_store 未返回 vectorStoreId");

  await supabasePublicJson(account, `/rest/v1/threads?id=eq.${threadId}`, {
    method: "PATCH",
    headers: {
      // 不强依赖返回值：与官方行为一致
      prefer: "return=minimal"
    },
    body: { vector_store_id: vectorStoreId, rag_enabled: true }
  });

  return vectorStoreId;
}

async function getSupabaseAuthUser(account) {
  const url = `${CONFIG.supabaseBase}/auth/v1/user`;
  const doOnce = async () => {
    return await fetchJson(url, {
      method: "GET",
      headers: {
        accept: "*/*",
        apikey: CONFIG.supabaseAnonKey,
        authorization: `Bearer ${account.accessToken}`
      }
    });
  };

  let res = await doOnce();
  if (res.status === 401 || res.status === 403) {
    await refreshSupabaseSession(account);
    res = await doOnce();
  }
  if (!res.ok) throw createUpstreamHttpError("Supabase user 获取失败", res);
  return res.json || null;
}

async function resolveProfileUserId(account, userId) {
  const current = String(userId || account.userId || "").trim();
  const authUser = await getSupabaseAuthUser(account);
  const resolved = String(authUser?.id || current).trim();
  if (!resolved) throw new Error("缺少 userId");

  if (account.userId !== resolved) {
    account.userId = resolved;
    await store.save();
  }
  return resolved;
}

async function getProfileSettings(account, userId, { resolvedUserId } = {}) {
  const uid = String(resolvedUserId || "").trim() || (await resolveProfileUserId(account, userId));
  return await supabasePublicJson(account, `/rest/v1/profiles?select=settings&id=eq.${uid}`, {
    method: "GET",
    headers: { accept: "application/vnd.pgrst.object+json" }
  });
}

function cloneJsonValue(value) {
  if (value === null || value === undefined) return value;
  if (typeof structuredClone === "function") return structuredClone(value);
  return JSON.parse(JSON.stringify(value));
}

async function patchProfileSettings(account, userId, updateSettings) {
  const uid = await resolveProfileUserId(account, userId);
  const existing = await getProfileSettings(account, uid, { resolvedUserId: uid });
  const settings = existing?.settings && typeof existing.settings === "object" ? existing.settings : {};
  const nextSettings = cloneJsonValue(settings) || {};
  updateSettings(nextSettings);

  return await supabasePublicJson(account, `/rest/v1/profiles?id=eq.${uid}&select=settings`, {
    method: "PATCH",
    headers: {
      accept: "application/vnd.pgrst.object+json",
      prefer: "return=representation"
    },
    body: { settings: nextSettings, updated_at: new Date().toISOString() }
  });
}

async function setProfileImageModel(account, userId, imageModel) {
  const raw = typeof imageModel === "string" ? imageModel.trim() : "";
  if (raw && !IMAGE_MODEL_IDS.includes(raw)) {
    throw createBadImageModelError(`不支持的图像模型：${raw}`);
  }
  return await patchProfileSettings(account, userId, (nextSettings) => {
    if (!nextSettings.preferences || typeof nextSettings.preferences !== "object") nextSettings.preferences = {};
    if (!raw) {
      delete nextSettings.preferences.image_model;
    } else {
      nextSettings.preferences.image_model = raw;
    }
  });
}

async function setProfileImageEditModel(account, userId, imageEditModel) {
  const raw = typeof imageEditModel === "string" ? imageEditModel.trim() : "";
  if (raw && !IMAGE_EDIT_MODEL_IDS.includes(raw)) {
    throw createBadImageModelError(`不支持的图像编辑模型：${raw}`);
  }
  return await patchProfileSettings(account, userId, (nextSettings) => {
    if (!nextSettings.preferences || typeof nextSettings.preferences !== "object") nextSettings.preferences = {};
    if (!raw) {
      delete nextSettings.preferences.image_edit_model;
    } else {
      nextSettings.preferences.image_edit_model = raw;
    }
  });
}

async function setProfileMemoryEnabled(account, userId, enabled) {
  const nextEnabled = Boolean(enabled);
  return await patchProfileSettings(account, userId, (nextSettings) => {
    if (!nextSettings.personalization || typeof nextSettings.personalization !== "object") {
      nextSettings.personalization = {};
    }
    nextSettings.personalization.enable_memories = nextEnabled;
  });
}

async function setProfileDefaultsOnImport(account, userId) {
  return await patchProfileSettings(account, userId, (nextSettings) => {
    if (!nextSettings.preferences || typeof nextSettings.preferences !== "object") nextSettings.preferences = {};
    nextSettings.preferences.image_model = DEFAULT_IMAGE_MODEL_ON_IMPORT;
    nextSettings.preferences.image_edit_model = DEFAULT_IMAGE_MODEL_ON_IMPORT;

    if (!nextSettings.personalization || typeof nextSettings.personalization !== "object") {
      nextSettings.personalization = {};
    }
    nextSettings.personalization.enable_memories = false;
  });
}

function extractProfileSettingsSnapshot(row) {
  const imageModel =
    typeof row?.settings?.preferences?.image_model === "string" ? row.settings.preferences.image_model : "";
  const imageEditModel =
    typeof row?.settings?.preferences?.image_edit_model === "string" ? row.settings.preferences.image_edit_model : "";
  const memoryEnabled = row?.settings?.personalization?.enable_memories === true;
  return { imageModel, imageEditModel, memoryEnabled };
}

function applyProfileSettingsSnapshotToAccount(account, snapshot) {
  const snap = snapshot && typeof snapshot === "object" ? snapshot : {};
  account.imageModel = typeof snap.imageModel === "string" ? snap.imageModel : "";
  account.imageEditModel = typeof snap.imageEditModel === "string" ? snap.imageEditModel : "";
  account.memoryEnabled = snap.memoryEnabled === true;
  account.profileSettingsSyncedAtMs = nowMs();
}

async function uploadRagFile(account, { threadId, filename, contentType, buffer, processAsync } = {}) {
  if (!buffer || !Buffer.isBuffer(buffer) || buffer.length === 0) throw createBadAttachmentsError("缺少图片文件内容");
  if (buffer.length > CONFIG.maxUploadBytes) throw createBadAttachmentsError("图片过大");
  const userId = account.userId || account.id;
  const safeName = sanitizeFilename(filename || `upload${extFromContentType(contentType) || ".bin"}`);
  const ct = String(contentType || "application/octet-stream");

  const form = new FormData();
  form.append("file", new Blob([buffer], { type: ct }), safeName);
  form.append("filename", safeName);
  form.append("contentType", ct);
  form.append("userId", userId);
  form.append("threadId", threadId);
  form.append("attributes", "{}");
  form.append("chunkingConfig", "{}");
  form.append("processAsync", processAsync === false ? "false" : "true");

  const url = `${CONFIG.zerotwoApiBase}/api/rag/upload`;
  const res = await fetchJson(url, {
    method: "POST",
    headers: buildZeroTwoAuthHeaders(account, { includeCsrf: true }),
    body: form
  });
  if (!res.ok) throw createUpstreamHttpError("rag/upload 失败", res);
  if (!res.json?.success || !res.json?.data) throw new Error("rag/upload 返回不完整");
  return res.json;
}

async function getFileProcessingQueue(account, queueId) {
  const sel = encodeURIComponent("status,processing_stage,processed_chunks,total_chunks,error_message");
  return await supabasePublicJson(
    account,
    `/rest/v1/file_processing_queue?select=${sel}&id=eq.${encodeURIComponent(queueId)}`,
    {
      method: "GET",
      headers: { accept: "application/vnd.pgrst.object+json" }
    }
  );
}

async function waitForFileProcessingCompletion(account, queueId, timeoutMs) {
  const deadline = nowMs() + Math.max(0, Number(timeoutMs || 0));
  let last = null;
  while (nowMs() < deadline) {
    const row = await getFileProcessingQueue(account, queueId);
    last = row;
    const status = String(row?.status || "").toLowerCase();
    if (status === "completed" || status === "failed") return row;
    await new Promise((r) => setTimeout(r, CONFIG.imageProcessingPollIntervalMs));
  }
  return last;
}

function buildZeroTwoAttachmentFromUploadData(d) {
  const fileId = String(d?.fileId || d?.file_id || d?.id || "");
  const name = String(d?.name || "");
  return {
    id: fileId,
    fileId,
    file_id: fileId,
    name,
    type: String(d?.type || d?.contentType || ""),
    size: Number(d?.size || 0) || 0,
    path: String(d?.path || ""),
    publicUrl: String(d?.publicUrl || ""),
    storage_path: String(d?.storage_path || d?.path || ""),
    vector_store_id: String(d?.vector_store_id || d?.vectorStoreId || ""),
    vectorStoreId: String(d?.vectorStoreId || d?.vector_store_id || ""),
    threadId: String(d?.threadId || ""),
    userId: String(d?.userId || "")
  };
}

function parseMultipartFormData(body, contentTypeHeader) {
  const ct = String(contentTypeHeader || "");
  const m = ct.match(/boundary=([^;]+)/i);
  const boundary = m ? m[1].trim().replace(/^"|"$/g, "") : "";
  if (!boundary) throw new Error("缺少 multipart boundary");
  const boundaryBuf = Buffer.from(`--${boundary}`);
  const headerSep = Buffer.from("\r\n\r\n");
  const crlf = Buffer.from("\r\n");

  const fields = {};
  const files = {};

  let pos = 0;
  for (;;) {
    const start = body.indexOf(boundaryBuf, pos);
    if (start === -1) break;
    pos = start + boundaryBuf.length;
    // 结束 boundary：--boundary--
    if (body.slice(pos, pos + 2).toString() === "--") break;
    // 跳过起始 CRLF
    if (body.slice(pos, pos + 2).equals(crlf)) pos += 2;

    const next = body.indexOf(boundaryBuf, pos);
    if (next === -1) break;
    const partBuf = body.slice(pos, next);
    pos = next;

    const headerEnd = partBuf.indexOf(headerSep);
    if (headerEnd === -1) continue;
    const headerText = partBuf.slice(0, headerEnd).toString("utf8");
    let contentBuf = partBuf.slice(headerEnd + headerSep.length);
    // 去掉结尾 CRLF
    if (contentBuf.length >= 2 && contentBuf.slice(contentBuf.length - 2).equals(crlf)) {
      contentBuf = contentBuf.slice(0, contentBuf.length - 2);
    }

    const headers = {};
    for (const line of headerText.split(/\r?\n/)) {
      const idx = line.indexOf(":");
      if (idx === -1) continue;
      const k = line.slice(0, idx).trim().toLowerCase();
      const v = line.slice(idx + 1).trim();
      headers[k] = v;
    }
    const cd = headers["content-disposition"] || "";
    const nameM = cd.match(/name="([^"]+)"/i);
    const filenameM = cd.match(/filename="([^"]*)"/i);
    const name = nameM ? nameM[1] : "";
    if (!name) continue;

    const partCt = headers["content-type"] || "text/plain";
    const filename = filenameM ? filenameM[1] : "";

    if (filenameM) {
      files[name] = { filename, contentType: partCt, buffer: contentBuf };
    } else {
      fields[name] = contentBuf.toString("utf8");
    }
  }

  return { fields, files };
}

function createMutex() {
  let last = Promise.resolve();
  return {
    async run(fn) {
      const prev = last;
      let release;
      last = new Promise((r) => (release = r));
      await prev;
      try {
        return await fn();
      } finally {
        release();
      }
    }
  };
}

class TokenStore {
  constructor(filePath) {
    this.filePath = filePath;
    this.accounts = new Map();
    this.runtime = new Map();
    this._saveMutex = createMutex();
  }

  async init() {
    await fsp.mkdir(path.dirname(this.filePath), { recursive: true });
    await this._load();
    for (const id of this.accounts.keys()) this._ensureRuntime(id);
  }

  _ensureRuntime(id) {
    if (this.runtime.has(id)) return;
    this.runtime.set(id, {
      refreshMutex: createMutex(),
      securityMutex: createMutex(),
      inflight: 0,
      circuitUntilMs: 0,
      authSecurityCooldownUntilMs: 0,
      lastError: null,
      consecutiveFailures: 0
    });
  }

  async _load() {
    try {
      const raw = await fsp.readFile(this.filePath, "utf8");
      const parsed = safeJsonParse(raw);
      if (!parsed.ok) throw new Error(parsed.error);
      const list = Array.isArray(parsed.value?.accounts) ? parsed.value.accounts : [];
      for (const a of list) {
        if (!a?.id || typeof a?.refreshToken !== "string") continue;
        const jwt = !a.email && a.accessToken ? parseJwtPayload(a.accessToken) : null;
        const jwtEmail =
          (typeof jwt?.email === "string" ? jwt.email : "") ||
          (typeof jwt?.user_metadata?.email === "string" ? jwt.user_metadata.email : "") ||
          "";
        const normalized = {
          id: a.id,
          email: typeof a.email === "string" ? a.email : jwtEmail,
          isPro: Boolean(a.isPro || a.label === "Pro"),
          disabled: Boolean(a.disabled),
          userId: a.userId || "",
          imageModel: typeof a.imageModel === "string" ? a.imageModel : "",
          imageEditModel: typeof a.imageEditModel === "string" ? a.imageEditModel : "",
          memoryEnabled: a.memoryEnabled === true,
          profileSettingsSyncedAtMs: Number(a.profileSettingsSyncedAtMs || 0),
          refreshToken: a.refreshToken,
          accessToken: a.accessToken || "",
          accessExpiresAtMs: Number(a.accessExpiresAtMs || 0),
          security: a.security || null,
          maxInflight: Number(a.maxInflight || 0)
        };
        this.accounts.set(a.id, normalized);
      }
    } catch (e) {
      if (String(e).includes("ENOENT")) return;
      throw e;
    }
  }

  async save() {
    await this._saveMutex.run(async () => {
      const accounts = [...this.accounts.values()].map((a) => ({
        id: a.id,
        email: a.email || "",
        isPro: Boolean(a.isPro),
        disabled: Boolean(a.disabled),
        userId: a.userId || "",
        imageModel: typeof a.imageModel === "string" ? a.imageModel : "",
        imageEditModel: typeof a.imageEditModel === "string" ? a.imageEditModel : "",
        memoryEnabled: a.memoryEnabled === true,
        profileSettingsSyncedAtMs: Number(a.profileSettingsSyncedAtMs || 0),
        refreshToken: a.refreshToken,
        accessToken: a.accessToken || "",
        accessExpiresAtMs: Number(a.accessExpiresAtMs || 0),
        security: a.security || null,
        maxInflight: Number(a.maxInflight || 0)
      }));
      const payload = JSON.stringify({ accounts }, null, 2);
      await fsp.writeFile(this.filePath, payload, "utf8");
    });
  }

  list() {
    const out = [];
    const now = nowMs();
    for (const a of this.accounts.values()) {
      const rt = this.runtime.get(a.id) || {};
      const jwt = !a.email && a.accessToken ? parseJwtPayload(a.accessToken) : null;
      const email =
        a.email ||
        (typeof jwt?.email === "string" ? jwt.email : "") ||
        (typeof jwt?.user_metadata?.email === "string" ? jwt.user_metadata.email : "") ||
        "";
      const circuitUntilMs = Number(rt.circuitUntilMs || 0);
      const inCircuit = circuitUntilMs > now;
      const authSecurityCooldownUntilMs = Number(rt.authSecurityCooldownUntilMs || 0);
      out.push({
        id: a.id,
        email,
        isPro: Boolean(a.isPro),
        disabled: Boolean(a.disabled),
        userId: a.userId || "",
        imageModel: typeof a.imageModel === "string" ? a.imageModel : "",
        imageEditModel: typeof a.imageEditModel === "string" ? a.imageEditModel : "",
        memoryEnabled: a.memoryEnabled === true,
        profileSettingsSyncedAtMs: Number(a.profileSettingsSyncedAtMs || 0),
        accessExpiresAtMs: Number(a.accessExpiresAtMs || 0),
        csrfExpiresAtMs: Number(a.security?.csrfExpiresAtMs || 0),
        inflight: Number(rt.inflight || 0),
        circuitUntilMs,
        authSecurityCooldownUntilMs,
        lastError: inCircuit ? rt.lastError || null : null,
        consecutiveFailures: Number(rt.consecutiveFailures || 0),
        maxInflight: Number(a.maxInflight || 0) || CONFIG.defaultMaxInflightPerAccount
      });
    }
    out.sort((x, y) => x.id.localeCompare(y.id));
    return out;
  }

  upsertFromAppSession(appSession) {
    const refreshToken = appSession?.refresh_token;
    if (typeof refreshToken !== "string" || !refreshToken) {
      throw new Error("app-session 缺少 refresh_token");
    }
    const id = appSession?.user?.id || randomId("acct");
    const userId = appSession?.user?.id || "";
    const email =
      appSession?.user?.email ||
      appSession?.user?.user_metadata?.email ||
      appSession?.user?.user_metadata?.mail ||
      "";
    const accessToken = appSession?.access_token || "";
    const accessExpiresAtSec = Number(appSession?.expires_at || 0);
    const accessExpiresAtMs = accessExpiresAtSec > 0 ? accessExpiresAtSec * 1000 : 0;

    const existing = this.accounts.get(id);
    const jwt = !email && accessToken ? parseJwtPayload(accessToken) : null;
    const jwtEmail =
      (typeof jwt?.email === "string" ? jwt.email : "") || (typeof jwt?.user_metadata?.email === "string" ? jwt.user_metadata.email : "");
    const account = {
      id,
      email: email || jwtEmail || existing?.email || "",
      isPro: Boolean(existing?.isPro),
      disabled: false,
      userId,
      imageModel: typeof existing?.imageModel === "string" ? existing.imageModel : "",
      imageEditModel: typeof existing?.imageEditModel === "string" ? existing.imageEditModel : "",
      memoryEnabled: existing?.memoryEnabled === true,
      profileSettingsSyncedAtMs: Number(existing?.profileSettingsSyncedAtMs || 0),
      refreshToken,
      accessToken: accessToken || existing?.accessToken || "",
      accessExpiresAtMs: accessExpiresAtMs || existing?.accessExpiresAtMs || 0,
      security: existing?.security || null,
      maxInflight: existing?.maxInflight || 0
    };
    this.accounts.set(id, account);
    this._ensureRuntime(id);
    return account;
  }

  get(id) {
    const a = this.accounts.get(id);
    if (!a) return null;
    this._ensureRuntime(id);
    return a;
  }

  setDisabled(id, disabled) {
    const a = this.get(id);
    if (!a) throw new Error("账号不存在");
    a.disabled = Boolean(disabled);
  }

  setMaxInflight(id, maxInflight) {
    const a = this.get(id);
    if (!a) throw new Error("账号不存在");
    const v = Number(maxInflight);
    if (!Number.isFinite(v) || v <= 0) throw new Error("maxInflight 必须是正数");
    a.maxInflight = v;
  }

  delete(id) {
    this.accounts.delete(id);
    this.runtime.delete(id);
  }

  runtimeState(id) {
    this._ensureRuntime(id);
    return this.runtime.get(id);
  }
}

const store = new TokenStore(CONFIG.accountsFile);
const runtimeFlags = {
  // 临时开关：开启后按 Pro 能力挑选账号，但不改动账号持久化层级。
  pseudoProEnabled: false
};

function isAccountProCapable(account) {
  return Boolean(account?.isPro) || runtimeFlags.pseudoProEnabled === true;
}

function classifyAuthFailure(status) {
  return status === 401 || status === 403;
}

function isAuthRateLimit429(status, text) {
  if (status !== 429) return false;
  const raw = String(text || "");
  const lower = raw.toLowerCase();
  // 仅当明确是“认证限流”时才跳过熔断；普通 rate limit 仍按失败处理
  if (lower.includes("authentication rate limit")) return true;
  const parsed = safeJsonParse(raw);
  if (!parsed.ok) return false;
  const err = parsed.value?.error;
  const msg = typeof err === "string" ? err : String(err?.message || err?.error || parsed.value?.message || parsed.value?.error || "");
  const msgLower = msg.toLowerCase();
  return msgLower.includes("authentication rate limit");
}

function shouldSkipCircuitBreak(error) {
  if (error?.skipCircuitBreak) return true;
  const status = Number(error?.status || 0);
  const raw = String(error?.body || error?.message || error || "");
  return isAuthRateLimit429(status, raw);
}

async function fetchJson(url, { method, headers, body, timeoutMs }) {
  const ac = new AbortController();
  const t = setTimeout(() => ac.abort(), timeoutMs || CONFIG.httpTimeoutMs);
  try {
    const hasBody = body !== undefined && body !== null;
    const isRawBody =
      hasBody &&
      (typeof body === "string" ||
        Buffer.isBuffer(body) ||
        body instanceof ArrayBuffer ||
        body instanceof Uint8Array ||
        (typeof FormData !== "undefined" && body instanceof FormData));
    const res = await fetch(url, {
      method,
      headers,
      body: hasBody ? (isRawBody ? body : JSON.stringify(body)) : undefined,
      signal: ac.signal
    });
    const text = await res.text();
    const parsed = safeJsonParse(text);
    return {
      ok: res.ok,
      status: res.status,
      headers: res.headers,
      text,
      json: parsed.ok ? parsed.value : null
    };
  } finally {
    clearTimeout(t);
  }
}

function buildZeroTwoAuthHeaders(account, { contentType, accept = "*/*", includeCsrf = true, extra } = {}) {
  const headers = {
    accept,
    authorization: `Bearer ${account.accessToken}`,
    origin: CONFIG.zerotwoOrigin,
    referer: `${CONFIG.zerotwoOrigin}/`
  };
  if (contentType) headers["content-type"] = contentType;
  if (includeCsrf) {
    const csrfToken = typeof account.security?.csrfToken === "string" ? account.security.csrfToken : "";
    if (csrfToken) headers["x-csrf-token"] = csrfToken;
    const csrfCookie = csrfCookieFromSecurity(account.security);
    if (csrfCookie) headers.cookie = csrfCookie;
  }
  if (extra && typeof extra === "object") Object.assign(headers, extra);
  return headers;
}

function createUpstreamHttpError(prefix, res) {
  const message = `${prefix}: ${res?.status || 0} ${String(res?.text || "").slice(0, 200)}`;
  const err = new Error(message);
  err.status = Number(res?.status || 0);
  err.body = String(res?.text || "");
  err.json = res?.json ?? null;
  return err;
}

function extractErrorCode(error) {
  const code = error?.json?.code || error?.json?.error?.code;
  if (typeof code === "string" && code) return code;
  const parsed = safeJsonParse(String(error?.body || ""));
  if (!parsed.ok) return "";
  const code2 = parsed.value?.code || parsed.value?.error?.code;
  return typeof code2 === "string" ? code2 : "";
}

function summarizeCircuitReason(error) {
  const status = Number(error?.status || 0);
  const code = extractErrorCode(error);
  const raw = String(error?.body || error?.message || "");
  const lower = raw.toLowerCase();

  if (status === 429) {
    const suffix = code ? `, ${code}` : "";
    if (isAuthRateLimit429(status, raw)) return `触发认证限流（429${suffix}）`;
    return `触发限流（429${suffix}）`;
  }
  if (status === 401 || status === 403) return `认证失败（${status}）`;
  if (lower.includes("abort") || lower.includes("timeout")) return "请求超时/中止";

  const msg = String(error?.message || error || "").trim();
  if (msg) return msg.length > 140 ? `${msg.slice(0, 140)}…` : msg;
  return "未知错误";
}

function computeAuthSecurityCooldownUntilMs() {
  const jitter = randIntInclusive(CONFIG.auth429SecurityCooldownJitterMinMs, CONFIG.auth429SecurityCooldownJitterMaxMs);
  return nowMs() + CONFIG.auth429SecurityCooldownMs + jitter;
}

async function refreshSupabaseSession(account) {
  return await store.runtimeState(account.id).refreshMutex.run(async () => {
    const now = nowMs();
    if (account.accessToken && account.accessExpiresAtMs - now > CONFIG.accessRefreshLeewayMs) {
      return { refreshed: false };
    }

    const url = `${CONFIG.supabaseBase}/auth/v1/token?grant_type=refresh_token`;
    const res = await fetchJson(url, {
      method: "POST",
      headers: {
        apikey: CONFIG.supabaseAnonKey,
        authorization: `Bearer ${CONFIG.supabaseAnonKey}`,
        "content-type": "application/json"
      },
      body: { refresh_token: account.refreshToken }
    });
    if (!res.ok) {
      throw createUpstreamHttpError("Supabase 刷新失败", res);
    }
    const accessToken = res.json?.access_token;
    const refreshToken = res.json?.refresh_token;
    const expiresAtSec = Number(res.json?.expires_at || 0);
    if (typeof accessToken !== "string" || !accessToken) throw new Error("Supabase 返回缺少 access_token");
    if (typeof refreshToken !== "string" || !refreshToken) throw new Error("Supabase 返回缺少 refresh_token");
    if (!expiresAtSec) throw new Error("Supabase 返回缺少 expires_at");

    account.accessToken = accessToken;
    account.refreshToken = refreshToken; // 轮换：务必覆盖
    account.accessExpiresAtMs = expiresAtSec * 1000;
    await store.save();
    return { refreshed: true };
  });
}

async function refreshSecurityTokens(account) {
  return await store.runtimeState(account.id).securityMutex.run(async () => {
    const now = nowMs();
    const sec = account.security || null;
    if (sec?.csrfToken && Number(sec.csrfExpiresAtMs || 0) - now > CONFIG.csrfRefreshLeewayMs) {
      return { refreshed: false };
    }

    const url = `${CONFIG.zerotwoApiBase}/api/auth/csrf-token`;
    const csrfCookie = csrfCookieFromSecurity(sec);
    const res = await fetchJson(url, {
      method: "GET",
      headers: {
        accept: "*/*",
        ...(account.accessToken ? { authorization: `Bearer ${account.accessToken}` } : {}),
        origin: CONFIG.zerotwoOrigin,
        referer: `${CONFIG.zerotwoOrigin}/`,
        ...(csrfCookie ? { cookie: csrfCookie } : {})
      },
      body: undefined
    });
    if (!res.ok || !res.json?.success) {
      const err = createUpstreamHttpError("csrf-token 失败", res);
      if (isAuthRateLimit429(res.status, res.text)) {
        const rt = store.runtimeState(account.id);
        rt.authSecurityCooldownUntilMs = computeAuthSecurityCooldownUntilMs();
        err.authSecurityCooldownUntilMs = rt.authSecurityCooldownUntilMs;
      }
      throw err;
    }

    const csrfToken = res.json?.token;
    const csrfTokenExpiresInSec = Number(res.json?.expiresIn || res.json?.expires_in || 0);
    if (typeof csrfToken !== "string" || !csrfToken) throw new Error("csrf-token 返回缺少 token");

    const nextSecurity = {
      csrfToken,
      csrfCookie: extractCsrfCookieFromHeaders(res.headers) || `__csrf=${csrfToken}`,
      csrfExpiresAtMs: now + (csrfTokenExpiresInSec > 0 ? csrfTokenExpiresInSec * 1000 : 24 * 60 * 60 * 1000),
      fetchedAtMs: now
    };
    account.security = nextSecurity;
    store.runtimeState(account.id).authSecurityCooldownUntilMs = 0;
    await store.save();
    return { refreshed: true };
  });
}

async function ensureAccountReady(account) {
  const now = nowMs();
  if (account.disabled) throw new Error("账号已禁用");
  if (account.accessToken && account.accessExpiresAtMs - now <= CONFIG.accessRefreshLeewayMs) {
    await refreshSupabaseSession(account);
  }
  if (!account.accessToken) await refreshSupabaseSession(account);

  const sec = account.security || null;
  const csrfExpired = !sec?.csrfToken || Number(sec.csrfExpiresAtMs || 0) - now <= CONFIG.csrfRefreshLeewayMs;
  if (csrfExpired) {
    await refreshSecurityTokens(account);
  }
}

function requiredProForProvider(provider) {
  const p = normalizeProviderName(provider);
  // 你要求：gemini/anthropic 需要 Pro 账号
  if (p === "gemini" || p === "anthropic") return true;
  return false;
}

function pickAccount({ requiredPro } = {}) {
  const now = nowMs();
  let bestInflight = Infinity;
  const best = [];
  for (const a of store.accounts.values()) {
    const rt = store.runtimeState(a.id);
    if (a.disabled) continue;
    if (requiredPro && !isAccountProCapable(a)) continue;
    if (rt.circuitUntilMs && rt.circuitUntilMs > now) continue;
    const maxInflight = Number(a.maxInflight || 0) || CONFIG.defaultMaxInflightPerAccount;
    if (rt.inflight >= maxInflight) continue;

    // 选择 inflight 最少的账号；若并列，则在并列集合里随机挑一个，避免低并发场景总是命中第一个账号。
    if (rt.inflight < bestInflight) {
      bestInflight = rt.inflight;
      best.length = 0;
      best.push(a);
      continue;
    }
    if (rt.inflight === bestInflight) best.push(a);
  }
  if (!best.length) return null;
  const idx = randIntInclusive(0, best.length - 1);
  return best[idx] || null;
}

async function withAccount({ requiredPro } = {}, fn) {
  const account = pickAccount({ requiredPro });
  if (!account) {
    const suffix = requiredPro ? "（需要 Pro 账号）" : "";
    const err = new Error(`暂无可用账号（可能全部熔断/并发已满/未导入）${suffix}`);
    err.code = "NO_ACCOUNT";
    throw err;
  }
  const rt = store.runtimeState(account.id);
  rt.inflight += 1;
  try {
    return await fn(account);
  } finally {
    rt.inflight -= 1;
  }
}

function markFailure(account, error, baseBackoffMs = 1000) {
  if (shouldSkipCircuitBreak(error)) return;
  const rt = store.runtimeState(account.id);
  rt.consecutiveFailures += 1;
  rt.lastError = summarizeCircuitReason(error);
  const jitter = Math.floor(Math.random() * 250);
  const backoff = Math.min(30_000, baseBackoffMs * Math.pow(2, Math.min(6, rt.consecutiveFailures - 1)));
  rt.circuitUntilMs = nowMs() + backoff + jitter;
}

function markSuccess(account) {
  const rt = store.runtimeState(account.id);
  rt.consecutiveFailures = 0;
  rt.lastError = null;
  rt.circuitUntilMs = 0;
}

function buildZeroTwoPlanFromOpenAI(openaiReq, account, requestMeta, threadId) {
  const { provider, model } = parseProviderModelFromOpenAIRequest(openaiReq);

  const messages = Array.isArray(openaiReq?.messages) ? openaiReq.messages : [];
  const systemParts = [];
  const zMessages = [];
  let lastNonSystemRole = "";
  for (const m of messages) {
    if (!m || typeof m !== "object") continue;
    const role = m.role;
    const content = extractTextFromMessageContent(m.content);
    if (role === "system") {
      if (content) systemParts.push(content);
      continue;
    }
    if (!role) continue;
    lastNonSystemRole = String(role);
    zMessages.push({ role, content, id: normalizeMessageId(m.id) });
  }

  // ZeroTwo 的前端会在最后附加一个空 assistant（用于承载流式输出的 messageId）。
  // 为了兼容 OpenAI 风格（通常最后一条是 user），这里自动补齐。
  if (zMessages.length === 0 || String(lastNonSystemRole).toLowerCase() !== "assistant") {
    zMessages.push({ role: "assistant", content: "", id: crypto.randomUUID ? crypto.randomUUID() : randomId("msg") });
  }

  const systemInstructions = systemParts.join("\n\n").trim();
  const topLevelInstructions = typeof openaiReq?.instructions === "string" ? openaiReq.instructions.trim() : "";
  // 你的代理主要接收 OpenAI 的 system messages：统一抽取并注入到 ZeroTwo 顶层 instructions。
  // 不支持/忽略 metadata.instructions（无此入参约定）。
  const instructions = systemInstructions || topLevelInstructions || "You are a helpful assistant.";
  const requestedEffort =
    openaiReq?.reasoning_effort ??
    openaiReq?.contextData?.reasoning_effort ??
    requestMeta?.reasoning_effort ??
    requestMeta?.contextData?.reasoning_effort ??
    "high";
  const normalizedProvider = normalizeProviderName(provider);

  // 上游只使用 reasoning_effort：payload/contextData 两处保持一致。
  // OpenAI/Gemini 上游支持字符串 high/medium/low；Anthropic(Claude) 上游支持数字预算或 off。
  let reasoningEffortValue = typeof requestedEffort === "string" ? requestedEffort : "high";

  if (normalizedProvider === "anthropic") {
    // Claude: thinking 仅作为入参兼容，用于推导 reasoning_effort；不透传给上游。
    const providedThinking = openaiReq?.thinking && typeof openaiReq.thinking === "object" ? openaiReq.thinking : null;
    if (providedThinking) {
      reasoningEffortValue = normalizeAnthropicThinkingToReasoningEffort(providedThinking, requestedEffort);
    } else {
      reasoningEffortValue = normalizeAnthropicReasoningEffort(requestedEffort);
    }
  }

  const baseContextData = {
    mode: { type: "thread", retrieval: null },
    active_app_id: null,
    active_mcp_server: null,
    is_hybrid_reasoning: true
  };

  const contextData = {
    ...baseContextData,
    ...(requestMeta?.contextData && typeof requestMeta.contextData === "object" ? requestMeta.contextData : {})
  };
  // 上游同时读取 payload/contextData：强制对齐，防止 requestMeta 覆盖。
  contextData.reasoning_effort = reasoningEffortValue;

  return {
    payload: {
      // 注意：某些上游会对请求体做严格校验（甚至包含字段顺序）。
      // 因此避免通过 spread 产生重复 key，确保 instructions 等关键字段位置稳定。
      provider,
      model,
      messages: zMessages,
      instructions,
      tool_choice: openaiReq?.tool_choice || "auto",
      reasoning_effort: reasoningEffortValue,
      contextData,
      featureId: "chat_stream",
      tracking: {
        userId: account.userId || account.id,
        ...(threadId ? { threadId } : {}),
        requestId: randomId("req"),
        timestamp: new Date().toISOString(),
        ...(isAccountProCapable(account) ? { plan: "pro" } : {})
      }
    }
  };
}

function getProvidedThreadIdFromRequest(openaiReq) {
  const m = openaiReq?.metadata;
  const candidates = [
    typeof openaiReq?.zerotwo_thread_id === "string" ? openaiReq.zerotwo_thread_id : "",
    typeof openaiReq?.thread_id === "string" ? openaiReq.thread_id : "",
    typeof m?.threadId === "string" ? m.threadId : "",
    typeof m?.thread_id === "string" ? m.thread_id : ""
  ].map((s) => (typeof s === "string" ? s.trim() : ""));
  const found = candidates.find((s) => s);
  return found || null;
}

function buildThreadIdFromRequest(openaiReq) {
  return getProvidedThreadIdFromRequest(openaiReq) || (crypto.randomUUID ? crypto.randomUUID() : randomId("thread"));
}

async function getExistingThreadVectorStoreId(account, threadId) {
  if (!threadId) return "";
  const threadSel = encodeURIComponent("id,vector_store_id,rag_enabled");
  const arr = await supabaseRestJson(account, `/rest/v1/threads?id=eq.${threadId}&select=${threadSel}`, { method: "GET" });
  const row = Array.isArray(arr) ? arr[0] : null;
  const vs = row?.vector_store_id;
  return typeof vs === "string" ? vs : "";
}

function normalizeMessageId(maybeId) {
  if (typeof maybeId === "string" && maybeId.trim()) return maybeId.trim();
  return crypto.randomUUID ? crypto.randomUUID() : randomId("msg");
}

function parseSseEventsFromTextChunk(state, chunkText, onEvent) {
  state.buffer += chunkText;
  for (;;) {
    const idxLf = state.buffer.indexOf("\n\n");
    const idxCrlf = state.buffer.indexOf("\r\n\r\n");
    let idx = -1;
    let delimLen = 0;
    if (idxLf !== -1 && (idxCrlf === -1 || idxLf < idxCrlf)) {
      idx = idxLf;
      delimLen = 2;
    } else if (idxCrlf !== -1) {
      idx = idxCrlf;
      delimLen = 4;
    }
    if (idx === -1) break;

    const raw = state.buffer.slice(0, idx);
    state.buffer = state.buffer.slice(idx + delimLen);
    const lines = raw.split(/\r?\n/);
    const dataLines = [];
    for (const line of lines) {
      if (line.startsWith("data:")) dataLines.push(line.slice("data:".length).trimStart());
    }
    if (!dataLines.length) continue;
    const data = dataLines.join("\n");
    onEvent(data);
  }
}

function buildOpenAIUsageFromZeroTwoUsage(u) {
  // 兼容 ZeroTwo(OpenAI) 与 ZeroTwo(Anthropic) 的 usage，并输出为 OpenAI Chat Completions 结构：
  // usage.prompt_tokens / usage.completion_tokens / usage.total_tokens
  // usage.prompt_tokens_details.cached_tokens / audio_tokens
  // usage.completion_tokens_details.reasoning_tokens / audio_tokens / accepted_prediction_tokens / rejected_prediction_tokens
  const prompt_tokens = Number(u?.prompt_tokens ?? u?.input_tokens ?? 0) || 0;
  const completion_tokens = Number(u?.completion_tokens ?? u?.output_tokens ?? 0) || 0;
  const total_tokens = Number(u?.total_tokens || 0) || prompt_tokens + completion_tokens;

  const reasoning_tokens =
    Number(u?.completion_tokens_details?.reasoning_tokens ?? u?.reasoning_tokens ?? 0) || 0;
  const cached_tokens =
    Number(
      u?.prompt_tokens_details?.cached_tokens ??
        u?.cached_tokens ??
        u?.cache_read_input_tokens ??
        0
    ) || 0;

  const prompt_audio_tokens = Number(u?.prompt_tokens_details?.audio_tokens ?? 0) || 0;
  const completion_audio_tokens = Number(u?.completion_tokens_details?.audio_tokens ?? 0) || 0;
  const accepted_prediction_tokens =
    Number(u?.completion_tokens_details?.accepted_prediction_tokens ?? 0) || 0;
  const rejected_prediction_tokens =
    Number(u?.completion_tokens_details?.rejected_prediction_tokens ?? 0) || 0;

  return {
    prompt_tokens,
    completion_tokens,
    total_tokens,
    prompt_tokens_details: {
      cached_tokens,
      audio_tokens: prompt_audio_tokens
    },
    completion_tokens_details: {
      reasoning_tokens,
      audio_tokens: completion_audio_tokens,
      accepted_prediction_tokens,
      rejected_prediction_tokens
    }
  };
}

async function handleChatCompletions(req, res) {
  const bodyBuf = await readBody(req, CONFIG.maxRequestBodyBytes);
  const parsed = safeJsonParse(bodyBuf.toString("utf8"));
  if (!parsed.ok) return sendJson(res, 400, { error: { message: "JSON 解析失败", type: "invalid_request_error" } });
  const openaiReq = parsed.value;
  const stream = Boolean(openaiReq?.stream);
  const includeUsage = stream ? true : Boolean(openaiReq?.stream_options?.include_usage);

  const { provider } = parseProviderModelFromOpenAIRequest(openaiReq);
  const requiredPro = requiredProForProvider(provider);

  return await withAccount({ requiredPro }, async (account) => {
    try {
      await ensureAccountReady(account);
      const providedThreadId = getProvidedThreadIdFromRequest(openaiReq);
      const threadId = providedThreadId || (crypto.randomUUID ? crypto.randomUUID() : randomId("thread"));
      const plan = buildZeroTwoPlanFromOpenAI(
        openaiReq,
        account,
        {
          // 统一从 OpenAI 请求推导 reasoning_effort（最终只发送 payload.reasoning_effort）
          reasoning_effort: openaiReq?.reasoning_effort ?? "high"
        },
        threadId
      );
      const payload = plan.payload;

      // 兼容 OpenAI multi-modal：若 messages 里出现 image_url/input_image，则自动上传并作为 attachments 注入。
      const imageUrls = extractImageUrlsFromOpenAIRequest(openaiReq);
      const hasExplicitAttachments = Array.isArray(openaiReq?.attachments) && openaiReq.attachments.length > 0;

      if (imageUrls.length && !hasExplicitAttachments) {
        const vsId = await ensureThreadVectorStore(account, threadId, { provider });
        payload.contextData.thread_vector_store_id = vsId;
        payload.contextData.vector_store_id = vsId;
        payload.contextData.mode = payload.contextData.mode || { type: "thread", retrieval: null };
        payload.contextData.mode.retrieval = ["thread"];

        const attachments = [];
        for (const u of imageUrls) {
          const resolved = await resolveImageToUploadBytes(u);
          const ct = String(resolved.contentType || "application/octet-stream");
          const ext = extFromContentType(ct) || ".bin";
          const name = `image_${randomId("img")}${ext}`.replace(/^image_/, ""); // 保持较短
          const up = await uploadRagFile(account, {
            threadId,
            filename: name,
            contentType: ct,
            buffer: resolved.buffer,
            processAsync: true
          });
          const d = up.data;
          attachments.push(buildZeroTwoAttachmentFromUploadData(d));

          const queueId = String(d?.queueId || "");
          if (queueId && CONFIG.imageProcessingWaitMs > 0) {
            await waitForFileProcessingCompletion(account, queueId, CONFIG.imageProcessingWaitMs);
          }
        }
        if (attachments.length) payload.attachments = attachments;
      } else if (hasExplicitAttachments) {
        // 若调用方已自行上传，则直接透传 attachments，并尽量补齐检索所需的 vector_store_id。
        payload.attachments = openaiReq.attachments;
        const first = openaiReq.attachments[0];
        const vs =
          (typeof first?.vectorStoreId === "string" ? first.vectorStoreId : "") ||
          (typeof first?.vector_store_id === "string" ? first.vector_store_id : "") ||
          "";
        if (vs) {
          payload.contextData.thread_vector_store_id = vs;
          payload.contextData.vector_store_id = vs;
          payload.contextData.mode = payload.contextData.mode || { type: "thread", retrieval: null };
          payload.contextData.mode.retrieval = ["thread"];
        }
      }

      let vectorStoreIdHint =
        typeof openaiReq?.metadata?.vectorStoreId === "string"
          ? openaiReq.metadata.vectorStoreId
          : typeof openaiReq?.metadata?.vector_store_id === "string"
            ? openaiReq.metadata.vector_store_id
            : "";

      // 若用户指定了 vector store 或使用已有 thread，则开启 thread 检索。
      let effectiveVs = vectorStoreIdHint || "";
      if (!effectiveVs && providedThreadId) {
        // 仅“读取”现有 thread 的向量库；不在没有上传的情况下自动创建，避免无意写库。
        effectiveVs = await getExistingThreadVectorStoreId(account, threadId);
      }
      if (effectiveVs) {
        payload.contextData.thread_vector_store_id = effectiveVs;
        payload.contextData.vector_store_id = effectiveVs;
        payload.contextData.mode = payload.contextData.mode || { type: "thread", retrieval: null };
        payload.contextData.mode.retrieval = ["thread"];
      }

      const url = `${CONFIG.zerotwoApiBase}/api/ai/chat/stream`;
      const ac = new AbortController();
      req.on("close", () => ac.abort());
      const timeout = setTimeout(() => ac.abort(), CONFIG.httpTimeoutMs);
      if (CONFIG.debugMode) {
        debugLog("upstream_request", {
          accountId: account.id,
          provider: payload.provider,
          model: payload.model,
          threadId: payload?.tracking?.threadId || "",
          featureId: payload.featureId || "",
          messageCount: Array.isArray(payload.messages) ? payload.messages.length : 0,
          reasoningEffort: payload.reasoning_effort,
          hasAttachments: Array.isArray(payload.attachments) && payload.attachments.length > 0
        });
        debugLog("upstream_request_payload", payload);
      }

      const zRes = await fetch(url, {
        method: "POST",
        headers: buildZeroTwoAuthHeaders(account, { contentType: "application/json", includeCsrf: true }),
        body: JSON.stringify(payload),
        signal: ac.signal
      }).finally(() => clearTimeout(timeout));

      if (!zRes.ok) {
        const text = await zRes.text();
        if (CONFIG.debugMode) {
          debugLog("upstream_non_2xx", {
            status: zRes.status,
            statusText: zRes.statusText || "",
            body: clipForLog(text)
          });
        }
        const err = new Error(`ZeroTwo 请求失败: ${zRes.status} ${text.slice(0, 200)}`);
        err.status = zRes.status;
        err.body = text;
        err.skipCircuitBreak = isAuthRateLimit429(zRes.status, text);
        throw err;
      }

      const result = await streamZeroTwoToOpenAI(zRes, openaiReq, res, { stream, includeUsage });
      markSuccess(account);
      return result;
    } catch (e) {
      if (!e?.skipCircuitBreak) markFailure(account, e);
      throw e;
    }
  });
}

async function handleRagUpload(req, res) {
  const bodyBuf = await readBody(req, CONFIG.maxUploadBytes);
  const parsed = parseMultipartFormData(bodyBuf, req.headers["content-type"]);
  const filePart = parsed.files.file;
  if (!filePart) throw createBadAttachmentsError("缺少 file 字段");

  const threadId = String(parsed.fields.threadId || "").trim();
  if (!threadId) throw createBadAttachmentsError("缺少 threadId");

  const filename = String(parsed.fields.filename || filePart.filename || "upload").trim();
  const contentType = String(parsed.fields.contentType || filePart.contentType || "application/octet-stream").trim();

  // 使用服务端账号，不信任前端透传 userId（避免越权）
  return await withAccount({}, async (account) => {
    await ensureAccountReady(account);
    await ensureThreadVectorStore(account, threadId, { provider: "openai" });

	    const up = await uploadRagFile(account, {
	      threadId,
	      filename,
	      contentType,
	      buffer: filePart.buffer,
	      processAsync: parsed.fields.processAsync !== "false"
	    });
	    return sendJson(res, 200, up);
	  });
}

async function handleFileProcessingQueueProxy(req, res, url) {
  const id = String(url.searchParams.get("id") || "").trim();
  if (!id) return sendJson(res, 400, { error: { message: "缺少 id" } });
  return await withAccount({}, async (account) => {
    await ensureAccountReady(account);
    const row = await getFileProcessingQueue(account, id);
    return sendJson(res, 200, row || null);
  });
}

async function streamZeroTwoToOpenAI(zRes, openaiReq, res, { stream, includeUsage }) {
  const created = Math.floor(Date.now() / 1000);
  const model = openaiReq?.model || "gpt-5.2";
  const id = randomId("chatcmpl");

  let content = "";
  let reasoning = "";
  let usage = null;
  let finished = false;

  if (stream) {
    res.writeHead(200, {
      "content-type": "text/event-stream; charset=utf-8",
      "cache-control": "no-cache",
      connection: "keep-alive"
    });
  }

  const state = { buffer: "" };
  const nodeStream = Readable.fromWeb(zRes.body);
  const decoder = new TextDecoder("utf-8");
  const rawStreamDebug = CONFIG.debugRawStream;

  const consumeSseData = (data) => {
    if (rawStreamDebug) debugLog("upstream_sse_data_raw", data);
    const parsed = safeJsonParse(data);
    if (!parsed.ok) {
      if (rawStreamDebug) debugLog("upstream_sse_data_parse_error", parsed.error || "json parse failed");
      return;
    }
    const msg = parsed.value;
    const entity = msg?.entity;
    const status = msg?.status;

    if (entity === "message.content" && status === "delta") {
      const t = msg?.v?.delta?.text;
      if (typeof t === "string" && t) {
        content += t;
        if (stream) {
          const chunkPayload = {
            id,
            object: "chat.completion.chunk",
            created,
            model,
            choices: [{ index: 0, delta: { content: t }, finish_reason: null }]
          };
          res.write(`data: ${JSON.stringify(chunkPayload)}\n\n`);
        }
      }
    }

    if (entity === "message.thinking" && status === "delta") {
      const r = msg?.v?.delta?.reasoning;
      if (typeof r === "string" && r) {
        reasoning += r;
        if (stream) {
          // 兼容“reasoning delta”习惯：不影响只认 content 的客户端
          const chunkPayload = {
            id,
            object: "chat.completion.chunk",
            created,
            model,
            choices: [{ index: 0, delta: { reasoning: r }, finish_reason: null }]
          };
          res.write(`data: ${JSON.stringify(chunkPayload)}\n\n`);
        }
      }
    }

    if (entity === "message" && status === "completed") {
      usage = buildOpenAIUsageFromZeroTwoUsage(msg?.v?.usage);
    }

    if (entity === "stream" && status === "completed") {
      finished = true;
    }
  };

  for await (const chunk of nodeStream) {
    // 重要：用流式 UTF-8 解码，避免多字节字符跨 chunk 导致 JSON 解析失败（Claude 中文/emoji 更容易触发）
    const text = decoder.decode(chunk, { stream: true });
    if (rawStreamDebug && text) debugLog("upstream_sse_chunk_raw", text);
    parseSseEventsFromTextChunk(state, text, consumeSseData);
  }
  // flush decoder
  const tail = decoder.decode();
  if (tail) {
    if (rawStreamDebug) debugLog("upstream_sse_tail_raw", tail);
    parseSseEventsFromTextChunk(state, tail, consumeSseData);
  }
  if (rawStreamDebug && state.buffer) {
    debugLog("upstream_sse_buffer_remaining", state.buffer);
  }

  if (stream) {
    const finalChunk = {
      id,
      object: "chat.completion.chunk",
      created,
      model,
      choices: [{ index: 0, delta: {}, finish_reason: "stop" }]
    };
    res.write(`data: ${JSON.stringify(finalChunk)}\n\n`);
    if (includeUsage && usage) {
      const usageChunk = { id, object: "chat.completion.chunk", created, model, choices: [], usage };
      res.write(`data: ${JSON.stringify(usageChunk)}\n\n`);
    }
    res.write("data: [DONE]\n\n");
    res.end();
    return;
  }

  if (!finished) {
    // 非严格：即便缺少 stream completed，也尽量返回聚合结果
  }

  const response = {
    id,
    object: "chat.completion",
    created,
    model,
    choices: [{ index: 0, message: { role: "assistant", content, ...(reasoning ? { reasoning } : {}) }, finish_reason: "stop" }],
    ...(usage ? { usage } : {})
  };
  sendJson(res, 200, response);
}

async function serveAdminAsset(res, filePath, contentType) {
  try {
    const body = await fsp.readFile(filePath);
    res.writeHead(200, { "content-type": contentType, "cache-control": "no-cache" });
    res.end(body);
  } catch (e) {
    res.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
    res.end("Admin 资源加载失败");
  }
}

async function serveAdminHtml(res) {
  const filePath = path.join(__dirname, "admin", "index.html");
  return await serveAdminAsset(res, filePath, "text/html; charset=utf-8");
}

async function handleAdminApi(req, res, url) {
  if (!requireApiKey(req)) return sendJson(res, 401, { error: { message: "缺少或错误的 API Key" } });

  if (req.method === "GET" && url.pathname === "/admin/api/accounts") {
    return sendJson(res, 200, { accounts: store.list(), pseudoProEnabled: runtimeFlags.pseudoProEnabled === true });
  }

  if (req.method === "POST" && url.pathname === "/admin/api/runtime/pseudo-pro") {
    const body = await readBody(req);
    const parsed = safeJsonParse(body.toString("utf8"));
    if (!parsed.ok) return sendJson(res, 400, { error: { message: "JSON 解析失败" } });
    if (typeof parsed.value?.enabled !== "boolean") {
      return sendJson(res, 400, { error: { message: "enabled 必须是布尔值" } });
    }
    runtimeFlags.pseudoProEnabled = parsed.value.enabled === true;
    return sendJson(res, 200, { ok: true, pseudoProEnabled: runtimeFlags.pseudoProEnabled === true });
  }

  if (req.method === "POST" && url.pathname === "/admin/api/accounts/refresh-profile-settings") {
    const accounts = [...store.accounts.values()].filter((a) => !a.disabled);
    let refreshed = 0;
    let failed = 0;
    let skipped = 0;
    const errors = [];

    for (const account of accounts) {
      if (!account.userId) {
        skipped += 1;
        continue;
      }
      try {
        await ensureAccountReady(account);
        const row = await getProfileSettings(account, account.userId);
        applyProfileSettingsSnapshotToAccount(account, extractProfileSettingsSnapshot(row));
        refreshed += 1;
      } catch (e) {
        failed += 1;
        errors.push({ id: account.id, message: String(e?.message || e || "") });
      }
    }

    await store.save();
    return sendJson(res, 200, { ok: true, refreshed, failed, skipped, errors });
  }

  if (req.method === "POST" && url.pathname === "/admin/api/accounts/import") {
    const body = await readBody(req);
    const parsed = safeJsonParse(body.toString("utf8"));
    if (!parsed.ok) return sendJson(res, 400, { error: { message: "JSON 解析失败" } });

    const appSessionRaw = parsed.value?.appSession;
    const isPro = Boolean(parsed.value?.isPro);
    if (typeof appSessionRaw !== "string" || !appSessionRaw.trim()) {
      return sendJson(res, 400, { error: { message: "缺少 appSession" } });
    }
    const appSessionParsed = safeJsonParse(appSessionRaw);
    if (!appSessionParsed.ok) return sendJson(res, 400, { error: { message: "app-session JSON 解析失败" } });

    const account = store.upsertFromAppSession(appSessionParsed.value);
    account.isPro = isPro;

    let memoryDefaulted = false;
    let imageModelDefaulted = false;
    let imageEditModelDefaulted = false;
    let profileDefaultError = "";
    if (account.userId) {
      try {
        await ensureAccountReady(account);
        const patched = await setProfileDefaultsOnImport(account, account.userId);
        const snap = extractProfileSettingsSnapshot(patched);
        applyProfileSettingsSnapshotToAccount(account, snap);
        memoryDefaulted = snap.memoryEnabled === false;
        imageModelDefaulted = snap.imageModel === DEFAULT_IMAGE_MODEL_ON_IMPORT;
        imageEditModelDefaulted = snap.imageEditModel === DEFAULT_IMAGE_MODEL_ON_IMPORT;
      } catch (e) {
        profileDefaultError = String(e?.message || e || "");
      }
    }

    await store.save();
    return sendJson(res, 200, {
      ok: true,
      account: { id: account.id },
      memory_defaulted: memoryDefaulted,
      image_model_defaulted: imageModelDefaulted,
      image_edit_model_defaulted: imageEditModelDefaulted,
      ...(profileDefaultError ? { profile_default_error: profileDefaultError } : {})
    });
  }

  const mTogglePro = url.pathname.match(/^\/admin\/api\/accounts\/([^/]+)\/toggle-pro$/);
  if (req.method === "POST" && mTogglePro) {
    const id = mTogglePro[1];
    const a = store.get(id);
    if (!a) return sendJson(res, 404, { error: { message: "账号不存在" } });
    a.isPro = !a.isPro;
    await store.save();
    return sendJson(res, 200, { ok: true, isPro: a.isPro });
  }

  const mToggle = url.pathname.match(/^\/admin\/api\/accounts\/([^/]+)\/toggle$/);
  if (req.method === "POST" && mToggle) {
    const id = mToggle[1];
    const a = store.get(id);
    if (!a) return sendJson(res, 404, { error: { message: "账号不存在" } });
    a.disabled = !a.disabled;
    await store.save();
    return sendJson(res, 200, { ok: true, disabled: a.disabled });
  }

  const mRefreshAccess = url.pathname.match(/^\/admin\/api\/accounts\/([^/]+)\/refresh-access$/);
  if (req.method === "POST" && mRefreshAccess) {
    const id = mRefreshAccess[1];
    const a = store.get(id);
    if (!a) return sendJson(res, 404, { error: { message: "账号不存在" } });
    await store.runtimeState(id).refreshMutex.run(async () => {
      a.accessExpiresAtMs = 0;
      a.accessToken = "";
    });
    await refreshSupabaseSession(a);
    return sendJson(res, 200, { ok: true });
  }

  const mRefreshSecurity = url.pathname.match(/^\/admin\/api\/accounts\/([^/]+)\/refresh-security$/);
  if (req.method === "POST" && mRefreshSecurity) {
    const id = mRefreshSecurity[1];
    const a = store.get(id);
    if (!a) return sendJson(res, 404, { error: { message: "账号不存在" } });
    a.security = null;
    await store.save();
    await refreshSecurityTokens(a);
    return sendJson(res, 200, { ok: true });
  }

  const mImageModel = url.pathname.match(/^\/admin\/api\/accounts\/([^/]+)\/image-model$/);
  if (mImageModel && req.method === "GET") {
    const id = mImageModel[1];
    const a = store.get(id);
    if (!a) return sendJson(res, 404, { error: { message: "账号不存在" } });
    const image_model = typeof a.imageModel === "string" ? a.imageModel : "";
    return sendJson(res, 200, { ok: true, userId: a.userId, image_model, available: IMAGE_MODEL_IDS });
  }
  if (mImageModel && req.method === "POST") {
    const id = mImageModel[1];
    const a = store.get(id);
    if (!a) return sendJson(res, 404, { error: { message: "账号不存在" } });
    const body = await readBody(req);
    const parsed = safeJsonParse(body.toString("utf8"));
    if (!parsed.ok) return sendJson(res, 400, { error: { message: "JSON 解析失败" } });
    const image_model = typeof parsed.value?.image_model === "string" ? parsed.value.image_model : "";
    await ensureAccountReady(a);
    const patched = await setProfileImageModel(a, a.userId, image_model);
    const snap = extractProfileSettingsSnapshot(patched);
    applyProfileSettingsSnapshotToAccount(a, snap);
    const next = snap.imageModel;
    await store.save();
    return sendJson(res, 200, { ok: true, userId: a.userId, image_model: next, available: IMAGE_MODEL_IDS });
  }

  const mImageEditModel = url.pathname.match(/^\/admin\/api\/accounts\/([^/]+)\/image-edit-model$/);
  if (mImageEditModel && req.method === "GET") {
    const id = mImageEditModel[1];
    const a = store.get(id);
    if (!a) return sendJson(res, 404, { error: { message: "账号不存在" } });
    const image_edit_model = typeof a.imageEditModel === "string" ? a.imageEditModel : "";
    return sendJson(res, 200, { ok: true, userId: a.userId, image_edit_model, available: IMAGE_EDIT_MODEL_IDS });
  }
  if (mImageEditModel && req.method === "POST") {
    const id = mImageEditModel[1];
    const a = store.get(id);
    if (!a) return sendJson(res, 404, { error: { message: "账号不存在" } });
    const body = await readBody(req);
    const parsed = safeJsonParse(body.toString("utf8"));
    if (!parsed.ok) return sendJson(res, 400, { error: { message: "JSON 解析失败" } });
    const image_edit_model = typeof parsed.value?.image_edit_model === "string" ? parsed.value.image_edit_model : "";
    await ensureAccountReady(a);
    const patched = await setProfileImageEditModel(a, a.userId, image_edit_model);
    const snap = extractProfileSettingsSnapshot(patched);
    applyProfileSettingsSnapshotToAccount(a, snap);
    const next = snap.imageEditModel;
    await store.save();
    return sendJson(res, 200, {
      ok: true,
      userId: a.userId,
      image_edit_model: next,
      available: IMAGE_EDIT_MODEL_IDS
    });
  }

  const mMemory = url.pathname.match(/^\/admin\/api\/accounts\/([^/]+)\/memory$/);
  if (mMemory && req.method === "GET") {
    const id = mMemory[1];
    const a = store.get(id);
    if (!a) return sendJson(res, 404, { error: { message: "账号不存在" } });
    const enabled = a.memoryEnabled === true;
    return sendJson(res, 200, { ok: true, userId: a.userId, enabled });
  }
  if (mMemory && req.method === "POST") {
    const id = mMemory[1];
    const a = store.get(id);
    if (!a) return sendJson(res, 404, { error: { message: "账号不存在" } });
    const body = await readBody(req);
    const parsed = safeJsonParse(body.toString("utf8"));
    if (!parsed.ok) return sendJson(res, 400, { error: { message: "JSON 解析失败" } });
    if (typeof parsed.value?.enabled !== "boolean") {
      return sendJson(res, 400, { error: { message: "enabled 必须是 boolean" } });
    }
    await ensureAccountReady(a);
    const patched = await setProfileMemoryEnabled(a, a.userId, parsed.value.enabled);
    const snap = extractProfileSettingsSnapshot(patched);
    applyProfileSettingsSnapshotToAccount(a, snap);
    const enabled = snap.memoryEnabled;
    await store.save();
    return sendJson(res, 200, { ok: true, userId: a.userId, enabled });
  }

  const mDelete = url.pathname.match(/^\/admin\/api\/accounts\/([^/]+)$/);
  if (req.method === "DELETE" && mDelete) {
    const id = mDelete[1];
    store.delete(id);
    await store.save();
    return sendJson(res, 200, { ok: true });
  }

  return sendJson(res, 404, { error: { message: "未找到" } });
}

async function backgroundTick() {
  const now = nowMs();
  const list = [...store.accounts.values()].filter((a) => !a.disabled);

  const candidates = [];
  for (const a of list) {
    const rt = store.runtimeState(a.id);
    if (rt.circuitUntilMs && rt.circuitUntilMs > now) continue;

    const needAccess = !a.accessToken || a.accessExpiresAtMs - now <= CONFIG.accessRefreshLeewayMs;
    const needCsrf = !a.security?.csrfToken || Number(a.security?.csrfExpiresAtMs || 0) - now <= CONFIG.csrfRefreshLeewayMs;
    const needSecurity = needCsrf;
    if (!needAccess && !needSecurity) continue;

    if (needSecurity) {
      const cooldownUntil = Number(rt.authSecurityCooldownUntilMs || 0);
      if (cooldownUntil && cooldownUntil > now) continue;
    }

    const dueAccessAt = !a.accessToken ? -Infinity : Number(a.accessExpiresAtMs || 0) - CONFIG.accessRefreshLeewayMs;
    const dueCsrfAt = !a.security?.csrfToken ? -Infinity : Number(a.security?.csrfExpiresAtMs || 0) - CONFIG.csrfRefreshLeewayMs;
    const dueSecurityAt = dueCsrfAt;
    const dueAt = Math.min(needAccess ? dueAccessAt : Infinity, needSecurity ? dueSecurityAt : Infinity);

    candidates.push({ a, dueAt });
  }

  candidates.sort((x, y) => x.dueAt - y.dueAt);
  const queue = candidates.slice(0, CONFIG.backgroundGroupSize).map((x) => x.a);
  let active = 0;
  return await new Promise((resolve) => {
    const pump = () => {
      while (active < CONFIG.backgroundMaxConcurrent && queue.length) {
        const a = queue.shift();
        active += 1;
        (async () => {
          const rt = store.runtimeState(a.id);
          if (rt.circuitUntilMs && rt.circuitUntilMs > now) return;
          const needAccess = !a.accessToken || a.accessExpiresAtMs - now <= CONFIG.accessRefreshLeewayMs;
          const needCsrf = !a.security?.csrfToken || Number(a.security?.csrfExpiresAtMs || 0) - now <= CONFIG.csrfRefreshLeewayMs;
          const needSecurity = needCsrf;
          if (!needAccess && !needSecurity) return;
          try {
            // Access 与 Security 拆分：避免 Security 的 auth 429 导致 20s 频率反复重试。
            if (needAccess) await refreshSupabaseSession(a);
            if (needSecurity) {
              const cooldownUntil = Number(rt.authSecurityCooldownUntilMs || 0);
              if (cooldownUntil && cooldownUntil > nowMs()) return;
              await refreshSecurityTokens(a);
            }
            markSuccess(a);
          } catch (e) {
            // 仅“authentication rate limit”类 429 设置冷却并跳过熔断；其余错误照常熔断退避。
            const raw = String(e?.body || e?.message || e || "");
            if (isAuthRateLimit429(Number(e?.status || 0), raw)) {
              rt.authSecurityCooldownUntilMs = computeAuthSecurityCooldownUntilMs();
              return;
            }
            markFailure(a, e);
          }
        })()
          .finally(() => {
            active -= 1;
            pump();
          });
      }
      if (!queue.length && active === 0) resolve();
    };
    pump();
  });
}

async function main() {
  await store.init();

  const server = http.createServer(async (req, res) => {
    try {
      const url = new URL(req.url, `http://${req.headers.host || "localhost"}`);
      if (req.method === "GET" && url.pathname === "/healthz") return sendText(res, 200, "ok\n");

      if (req.method === "GET" && url.pathname === "/admin") return await serveAdminHtml(res);
      if (req.method === "GET" && url.pathname === "/admin.css") {
        const filePath = path.join(__dirname, "admin", "admin.css");
        return await serveAdminAsset(res, filePath, "text/css; charset=utf-8");
      }
      if (req.method === "GET" && url.pathname === "/admin.js") {
        const filePath = path.join(__dirname, "admin", "admin.js");
        return await serveAdminAsset(res, filePath, "application/javascript; charset=utf-8");
      }
      if (url.pathname.startsWith("/admin/api/")) return await handleAdminApi(req, res, url);

      if (url.pathname === "/v1/chat/completions" && req.method === "POST") {
        if (!requireApiKey(req)) return sendJson(res, 401, { error: { message: "缺少或错误的 API Key" } });
        return await handleChatCompletions(req, res);
      }

      if (url.pathname === "/api/rag/upload" && req.method === "POST") {
        // 注意：该接口与浏览器/前端交互时，Authorization 往往用于 Supabase JWT，因此使用 x-api-key 进行鉴权。
        if (!requireApiKey(req)) return sendJson(res, 401, { error: { message: "缺少或错误的 API Key" } });
        return await handleRagUpload(req, res);
      }

      if (url.pathname === "/api/rag/file-processing-queue" && req.method === "GET") {
        if (!requireApiKey(req)) return sendJson(res, 401, { error: { message: "缺少或错误的 API Key" } });
        return await handleFileProcessingQueueProxy(req, res, url);
      }

      return sendJson(res, 404, { error: { message: "未找到" } });
	    } catch (e) {
	      if (e?.code === "BAD_ATTACHMENTS") {
	        return sendJson(res, 400, { error: { message: String(e?.message || e), type: "invalid_request_error" } });
	      }
	      if (e?.code === "BAD_IMAGE_MODEL") {
	        return sendJson(res, 400, { error: { message: String(e?.message || e), type: "invalid_request_error" } });
	      }
	      if (e?.code === "NO_ACCOUNT") {
	        return sendJson(res, 503, { error: { message: String(e?.message || e), type: "server_error" } });
	      }
	      return sendJson(res, 500, { error: { message: String(e?.message || e) } });
	    }
	  });

  server.listen(CONFIG.port, CONFIG.host, () => {
    console.log(`[server] listening on http://${CONFIG.host}:${CONFIG.port}`);
    if (CONFIG.apiKey === "change-me") console.log("[server] 警告：请设置环境变量 API_KEY");
  });

  let backgroundRunning = false;
  setInterval(() => {
    if (backgroundRunning) return;
    backgroundRunning = true;
    backgroundTick()
      .catch(() => {})
      .finally(() => {
        backgroundRunning = false;
      });
  }, CONFIG.backgroundTickMs).unref();
}

main().catch((e) => {
  console.error(e);
  process.exit(1);
});