@fudrouter/fsrouter 0.6.59 → 0.6.60

package/open-sse/executors/chatgpt-web.js

@@ -1,2042 +0,0 @@
-import { BaseExecutor } from "./base.ts";
-import { describeChatGptWebHttpError } from "./chatgptWebErrors.ts";
-import { prepareToolMessages } from "../translator/webTools.ts";
-import { buildToolModeResponse } from "./chatgptWebTools.ts";
-import { createHash, randomUUID, randomBytes } from "node:crypto";
-import { sha3_512Hex } from "../utils/sha3-512.ts";
-import {
-  tlsFetchChatGpt,
-  TlsClientUnavailableError
-} from "../services/chatgptTlsClient.ts";
-import {
-  storeChatGptImage,
-  getChatGptImageConversationContext,
-  __resetChatGptImageCacheForTesting
-} from "../services/chatgptImageCache.ts";
-import { isThinkingCapableModel, resolveChatGptModel } from "./chatgpt-web/models.ts";
-const CHATGPT_BASE = "https://chatgpt.com";
-const SESSION_URL = `${CHATGPT_BASE}/api/auth/session`;
-const SENTINEL_PREPARE_URL = `${CHATGPT_BASE}/backend-api/sentinel/chat-requirements/prepare`;
-const SENTINEL_CR_URL = `${CHATGPT_BASE}/backend-api/sentinel/chat-requirements`;
-const CONV_URL = `${CHATGPT_BASE}/backend-api/f/conversation`;
-const USER_LAST_USED_MODEL_CONFIG_URL = `${CHATGPT_BASE}/backend-api/settings/user_last_used_model_config`;
-const DEFAULT_PRO_POLL_TIMEOUT_MS = 20 * 6e4;
-const DEFAULT_PRO_POLL_INTERVAL_MS = 4e3;
-const CHATGPT_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:152.0) Gecko/20100101 Firefox/152.0";
-const OAI_CLIENT_VERSION = "prod-81e0c5cdf6140e8c5db714d613337f4aeab94029";
-const OAI_CLIENT_BUILD_NUMBER = "6128297";
-const deviceIdCache = /* @__PURE__ */ new Map();
-function deviceIdFor(cookie) {
-  const key = cookieKey(cookie);
-  let id = deviceIdCache.get(key);
-  if (!id) {
-    const h = createHash("sha256").update(cookie).digest("hex");
-    id = `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-${(parseInt(h.slice(16, 17), 16) & 3 | 8).toString(16)}${h.slice(17, 20)}-` + h.slice(20, 32);
-    if (deviceIdCache.size >= 200) {
-      const first = deviceIdCache.keys().next().value;
-      if (first) deviceIdCache.delete(first);
-    }
-    deviceIdCache.set(key, id);
-  }
-  return id;
-}
-function browserHeaders() {
-  return {
-    Accept: "*/*",
-    "Accept-Language": "en-US,en;q=0.9",
-    "Cache-Control": "no-cache",
-    Origin: CHATGPT_BASE,
-    Pragma: "no-cache",
-    Referer: `${CHATGPT_BASE}/`,
-    "Sec-Fetch-Dest": "empty",
-    "Sec-Fetch-Mode": "cors",
-    "Sec-Fetch-Site": "same-origin",
-    "User-Agent": CHATGPT_USER_AGENT
-  };
-}
-function oaiHeaders(sessionId, deviceId) {
-  return {
-    "OAI-Language": "en-US",
-    "OAI-Device-Id": deviceId,
-    "OAI-Client-Version": OAI_CLIENT_VERSION,
-    "OAI-Client-Build-Number": OAI_CLIENT_BUILD_NUMBER,
-    "OAI-Session-Id": sessionId
-  };
-}
-const TOKEN_TTL_MS = 5 * 60 * 1e3;
-const tokenCache = /* @__PURE__ */ new Map();
-function cookieKey(cookie) {
-  return createHash("sha256").update(cookie).digest("hex").slice(0, 16);
-}
-function tokenLookup(cookie) {
-  const entry = tokenCache.get(cookieKey(cookie));
-  if (!entry) return null;
-  if (Date.now() >= entry.expiresAt) {
-    tokenCache.delete(cookieKey(cookie));
-    return null;
-  }
-  return entry;
-}
-const TOKEN_CACHE_MAX = 200;
-function tokenStore(cookie, entry) {
-  if (tokenCache.size >= TOKEN_CACHE_MAX && !tokenCache.has(cookieKey(cookie))) {
-    const firstKey = tokenCache.keys().next().value;
-    if (firstKey) tokenCache.delete(firstKey);
-  }
-  tokenCache.set(cookieKey(cookie), entry);
-}
-const SESSION_TOKEN_FAMILY_RE = /^__Secure-next-auth\.session-token(?:\.\d+)?$/;
-function mergeRefreshedCookie(originalCookie, setCookieHeader) {
-  if (!setCookieHeader) return null;
-  const matches = Array.from(
-    setCookieHeader.matchAll(/(__Secure-next-auth\.session-token(?:\.\d+)?)=([^;,\s]+)/g)
-  );
-  if (matches.length === 0) return null;
-  const refreshed = /* @__PURE__ */ new Map();
-  for (const m of matches) refreshed.set(m[1], m[2]);
-  let blob = originalCookie.trim();
-  if (/^cookie\s*:\s*/i.test(blob)) blob = blob.replace(/^cookie\s*:\s*/i, "");
-  if (!/=/.test(blob)) {
-    return Array.from(refreshed, ([k, v]) => `${k}=${v}`).join("; ");
-  }
-  const pairs = blob.split(/;\s*/).filter(Boolean);
-  const result = [];
-  let mutated = false;
-  let droppedStale = false;
-  for (const pair of pairs) {
-    const eqIdx = pair.indexOf("=");
-    if (eqIdx < 0) {
-      result.push(pair);
-      continue;
-    }
-    const name = pair.slice(0, eqIdx).trim();
-    const value = pair.slice(eqIdx + 1);
-    if (SESSION_TOKEN_FAMILY_RE.test(name)) {
-      if (!refreshed.has(name) || refreshed.get(name) !== value) mutated = true;
-      droppedStale = true;
-      continue;
-    }
-    result.push(`${name}=${value}`);
-  }
-  for (const [name, value] of refreshed) {
-    result.push(`${name}=${value}`);
-  }
-  if (!droppedStale) mutated = true;
-  return mutated ? result.join("; ") : null;
-}
-function buildSessionCookieHeader(rawInput) {
-  let s = rawInput.trim();
-  if (/^cookie\s*:\s*/i.test(s)) s = s.replace(/^cookie\s*:\s*/i, "");
-  if (/__Secure-next-auth\.session-token(?:\.\d+)?\s*=/.test(s)) {
-    return s;
-  }
-  return `__Secure-next-auth.session-token=${s}`;
-}
-async function exchangeSession(cookie, signal) {
-  const cached = tokenLookup(cookie);
-  if (cached) return cached;
-  const headers = {
-    ...browserHeaders(),
-    Accept: "application/json",
-    Cookie: buildSessionCookieHeader(cookie)
-  };
-  const response = await tlsFetchChatGpt(SESSION_URL, {
-    method: "GET",
-    headers,
-    timeoutMs: 3e4,
-    signal
-  });
-  if (response.status === 401 || response.status === 403) {
-    throw new SessionAuthError("Invalid session cookie");
-  }
-  if (response.status >= 400) {
-    throw new Error(`Session exchange failed (HTTP ${response.status})`);
-  }
-  const refreshed = mergeRefreshedCookie(cookie, response.headers.get("set-cookie"));
-  let data = {};
-  try {
-    data = JSON.parse(response.text || "{}");
-  } catch {
-    console.warn("[chatgpt-web] session response JSON parse failed");
-  }
-  if (!data.accessToken) {
-    throw new SessionAuthError("Session response missing accessToken \u2014 cookie likely expired");
-  }
-  const expiresAt = data.expires ? new Date(data.expires).getTime() : Date.now() + TOKEN_TTL_MS;
-  const entry = {
-    accessToken: data.accessToken,
-    accountId: data.user?.id ?? null,
-    expiresAt: Math.min(expiresAt, Date.now() + TOKEN_TTL_MS),
-    refreshedCookie: refreshed ?? void 0
-  };
-  tokenStore(cookie, entry);
-  return entry;
-}
-class SessionAuthError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SessionAuthError";
-  }
-}
-const warmupCache = /* @__PURE__ */ new Map();
-const WARMUP_TTL_MS = 6e4;
-const WARMUP_CACHE_MAX = 200;
-async function runSessionWarmup(accessToken, accountId, sessionId, deviceId, cookie, signal, log) {
-  const key = cookieKey(cookie) + ":" + accessToken.slice(-8);
-  const now = Date.now();
-  const last = warmupCache.get(key);
-  if (last && now - last < WARMUP_TTL_MS) return;
-  if (warmupCache.size >= WARMUP_CACHE_MAX && !warmupCache.has(key)) {
-    const first = warmupCache.keys().next().value;
-    if (first) warmupCache.delete(first);
-  }
-  warmupCache.set(key, now);
-  const headers = {
-    ...browserHeaders(),
-    ...oaiHeaders(sessionId, deviceId),
-    Accept: "*/*",
-    Authorization: `Bearer ${accessToken}`,
-    Cookie: buildSessionCookieHeader(cookie),
-    Priority: "u=1, i"
-  };
-  if (accountId) headers["chatgpt-account-id"] = accountId;
-  const urls = [
-    `${CHATGPT_BASE}/backend-api/me`,
-    `${CHATGPT_BASE}/backend-api/conversations?offset=0&limit=28&order=updated`,
-    `${CHATGPT_BASE}/backend-api/models?history_and_training_disabled=false`
-  ];
-  for (const url of urls) {
-    try {
-      const r = await tlsFetchChatGpt(url, {
-        method: "GET",
-        headers,
-        timeoutMs: 15e3,
-        signal
-      });
-      log?.debug?.("CGPT-WEB", `warmup ${url.split("/backend-api/")[1]} \u2192 ${r.status}`);
-    } catch (err) {
-      log?.debug?.(
-        "CGPT-WEB",
-        `warmup ${url} failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-}
-const thinkingEffortCache = /* @__PURE__ */ new Map();
-const THINKING_EFFORT_TTL_MS = 5 * 60 * 1e3;
-const THINKING_EFFORT_CACHE_MAX = 400;
-function configuredProPollTimeoutMs() {
-  const raw = Number(process.env.OMNIROUTE_CGPT_WEB_PRO_TIMEOUT_MS);
-  if (!Number.isFinite(raw) || raw <= 0) return DEFAULT_PRO_POLL_TIMEOUT_MS;
-  return Math.floor(raw);
-}
-function configuredProPollIntervalMs() {
-  const raw = Number(process.env.OMNIROUTE_CGPT_WEB_PRO_POLL_INTERVAL_MS);
-  if (!Number.isFinite(raw) || raw <= 0) return DEFAULT_PRO_POLL_INTERVAL_MS;
-  return Math.floor(raw);
-}
-async function setUserThinkingEffort(modelSlug, effort, accessToken, accountId, sessionId, deviceId, cookie, signal, log) {
-  const cacheKey = `${cookieKey(cookie)}:${modelSlug}:${effort}`;
-  const now = Date.now();
-  const last = thinkingEffortCache.get(cacheKey);
-  if (last && now - last < THINKING_EFFORT_TTL_MS) {
-    log?.debug?.("CGPT-WEB", `thinking_effort cached (${modelSlug}=${effort}) \u2014 skip PATCH`);
-    return;
-  }
-  if (thinkingEffortCache.size >= THINKING_EFFORT_CACHE_MAX && !thinkingEffortCache.has(cacheKey)) {
-    const first = thinkingEffortCache.keys().next().value;
-    if (first) thinkingEffortCache.delete(first);
-  }
-  const url = `${USER_LAST_USED_MODEL_CONFIG_URL}?model_slug=${encodeURIComponent(modelSlug)}&thinking_effort=${encodeURIComponent(effort)}`;
-  const headers = {
-    ...browserHeaders(),
-    ...oaiHeaders(sessionId, deviceId),
-    Accept: "application/json",
-    Authorization: `Bearer ${accessToken}`,
-    Cookie: buildSessionCookieHeader(cookie),
-    Priority: "u=4"
-  };
-  if (accountId) headers["chatgpt-account-id"] = accountId;
-  try {
-    const r = await tlsFetchChatGpt(url, {
-      method: "PATCH",
-      headers,
-      timeoutMs: 15e3,
-      signal
-    });
-    if (r.status >= 400) {
-      log?.warn?.(
-        "CGPT-WEB",
-        `thinking_effort PATCH ${r.status} for ${modelSlug}=${effort} (continuing)`
-      );
-      return;
-    }
-    thinkingEffortCache.set(cacheKey, now);
-    log?.debug?.("CGPT-WEB", `thinking_effort PATCH OK (${modelSlug}=${effort})`);
-  } catch (err) {
-    log?.warn?.(
-      "CGPT-WEB",
-      `thinking_effort PATCH failed: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-}
-async function prepareChatRequirements(accessToken, accountId, sessionId, deviceId, cookie, dplInfo, signal, log) {
-  const config = buildPrekeyConfig(CHATGPT_USER_AGENT, dplInfo.dpl, dplInfo.scriptSrc);
-  const prekey = await buildPrepareToken(config, log);
-  const headers = {
-    ...browserHeaders(),
-    ...oaiHeaders(sessionId, deviceId),
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${accessToken}`,
-    Cookie: buildSessionCookieHeader(cookie),
-    Priority: "u=1, i"
-  };
-  if (accountId) headers["chatgpt-account-id"] = accountId;
-  const prepResp = await tlsFetchChatGpt(SENTINEL_PREPARE_URL, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({ p: prekey }),
-    timeoutMs: 3e4,
-    signal
-  });
-  if (prepResp.status === 401 || prepResp.status === 403) {
-    throw new SentinelBlockedError(`Sentinel /prepare blocked (HTTP ${prepResp.status})`);
-  }
-  if (prepResp.status >= 400) {
-    throw new Error(`Sentinel /prepare failed (HTTP ${prepResp.status})`);
-  }
-  let prepData = {};
-  try {
-    prepData = JSON.parse(prepResp.text || "{}");
-  } catch {
-    console.warn("[chatgpt-web] chat requirements prep JSON parse failed");
-  }
-  if (!prepData.prepare_token) {
-    return prepData;
-  }
-  const crBody = { p: prekey, prepare_token: prepData.prepare_token };
-  const crResp = await tlsFetchChatGpt(SENTINEL_CR_URL, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(crBody),
-    timeoutMs: 3e4,
-    signal
-  });
-  if (crResp.status === 401 || crResp.status === 403) {
-    throw new SentinelBlockedError(`Sentinel /chat-requirements blocked (HTTP ${crResp.status})`);
-  }
-  if (crResp.status >= 400) {
-    return prepData;
-  }
-  try {
-    const crData = JSON.parse(crResp.text || "{}");
-    return { ...crData, prepare_token: prepData.prepare_token };
-  } catch {
-    console.warn("[chatgpt-web] chat requirements response JSON parse failed");
-    return prepData;
-  }
-}
-class SentinelBlockedError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SentinelBlockedError";
-  }
-}
-let dplCache = null;
-const DPL_TTL_MS = 60 * 60 * 1e3;
-async function fetchDpl(cookie, signal) {
-  if (dplCache && Date.now() < dplCache.expiresAt) {
-    return { dpl: dplCache.dpl, scriptSrc: dplCache.scriptSrc };
-  }
-  const headers = {
-    ...browserHeaders(),
-    Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
-    Cookie: buildSessionCookieHeader(cookie)
-  };
-  const response = await tlsFetchChatGpt(`${CHATGPT_BASE}/`, {
-    method: "GET",
-    headers,
-    timeoutMs: 2e4,
-    signal
-  });
-  const html = response.text || "";
-  const dplMatch = html.match(/data-build="([^"]+)"/);
-  const dpl = dplMatch ? `dpl=${dplMatch[1]}` : `dpl=${OAI_CLIENT_VERSION.replace(/^prod-/, "")}`;
-  const scriptMatch = html.match(/<script[^>]+src="(https?:\/\/[^"]*\.js[^"]*)"/);
-  const scriptSrc = scriptMatch?.[1] ?? `${CHATGPT_BASE}/_next/static/chunks/webpack-${randomHex(16)}.js`;
-  dplCache = { dpl, scriptSrc, expiresAt: Date.now() + DPL_TTL_MS };
-  return { dpl, scriptSrc };
-}
-function randomHex(n) {
-  return randomBytes(Math.ceil(n / 2)).toString("hex").slice(0, n);
-}
-const NAVIGATOR_KEYS = [
-  "webdriver\u2212false",
-  "geolocation",
-  "languages",
-  "language",
-  "platform",
-  "userAgent",
-  "vendor",
-  "hardwareConcurrency",
-  "deviceMemory",
-  "permissions",
-  "plugins",
-  "mediaDevices"
-];
-const DOCUMENT_KEYS = [
-  "_reactListeningkfj3eavmks",
-  "_reactListeningo743lnnpvdg",
-  "location",
-  "scrollingElement",
-  "documentElement"
-];
-const WINDOW_KEYS = [
-  "webpackChunk_N_E",
-  "__NEXT_DATA__",
-  "chrome",
-  "history",
-  "screen",
-  "navigation",
-  "scrollX",
-  "scrollY"
-];
-function pick(arr) {
-  return arr[Math.floor(Math.random() * arr.length)];
-}
-function buildPrekeyConfig(userAgent, dpl, scriptSrc) {
-  const screenSizes = [3e3, 4e3, 3120, 4160];
-  const cores = [8, 16, 24, 32];
-  const dateStr = (/* @__PURE__ */ new Date()).toString();
-  const perfNow = performance.now();
-  const epochOffset = Date.now() - perfNow;
-  return [
-    pick(screenSizes),
-    dateStr,
-    4294705152,
-    0,
-    // mutated by solver
-    userAgent,
-    scriptSrc,
-    dpl,
-    "en-US",
-    "en-US,en",
-    0,
-    // mutated by solver
-    pick(NAVIGATOR_KEYS),
-    pick(DOCUMENT_KEYS),
-    pick(WINDOW_KEYS),
-    perfNow,
-    randomUUID(),
-    "",
-    pick(cores),
-    epochOffset
-  ];
-}
-const POW_YIELD_EVERY = 1e3;
-function yieldToEventLoop() {
-  return new Promise((resolve) => setImmediate(resolve));
-}
-async function solvePow(opts) {
-  const cfg = [...opts.config];
-  for (let i = 0; i < opts.maxIter; i++) {
-    if (i > 0 && i % POW_YIELD_EVERY === 0) await yieldToEventLoop();
-    cfg[3] = i;
-    const json = JSON.stringify(cfg);
-    const b642 = Buffer.from(json).toString("base64");
-    const hash = sha3_512Hex(opts.seed + b642);
-    if (opts.target && hash.slice(0, opts.target.length) <= opts.target) {
-      return `${opts.prefix}${b642}`;
-    }
-  }
-  opts.log?.warn?.(
-    "CGPT-WEB",
-    `PoW (${opts.label}) exhausted ${opts.maxIter} iterations against target=${opts.target || "<empty>"}; submitting unsolved token (Sentinel may reject)`
-  );
-  const b64 = Buffer.from(JSON.stringify(cfg)).toString("base64");
-  return `${opts.prefix}${b64}`;
-}
-async function buildPrepareToken(config, log) {
-  return solvePow({
-    config,
-    seed: "",
-    target: "0fffff",
-    prefix: "gAAAAAC",
-    maxIter: 1e5,
-    label: "prepare",
-    log
-  });
-}
-async function solveProofOfWork(seed, difficulty, config, log) {
-  return solvePow({
-    config,
-    seed,
-    target: (difficulty || "").toLowerCase(),
-    prefix: "gAAAAAB",
-    maxIter: 5e5,
-    label: "conversation",
-    log
-  });
-}
-const DATA_URI_IMAGE_RE = /!\[([^\]]*)\]\(data:image\/[^)]+\)/g;
-const CACHED_IMAGE_URL_RE = /\/v1\/chatgpt-web\/image\/([a-f0-9]{16,64})(?=[)\s"'<>]|$)/gi;
-function stripInlinedImages(content) {
-  return content.replace(
-    DATA_URI_IMAGE_RE,
-    (_, alt) => alt ? `[${alt}: generated image]` : "[generated image]"
-  );
-}
-function findCachedImageContext(content) {
-  let latest = null;
-  for (const match of content.matchAll(CACHED_IMAGE_URL_RE)) {
-    const id = match[1];
-    const context = getChatGptImageConversationContext(id);
-    if (context) latest = context;
-  }
-  return latest;
-}
-function parseOpenAIMessages(messages) {
-  let systemMsg = "";
-  const history = [];
-  let latestImageContext = null;
-  for (const msg of messages) {
-    let role = String(msg.role || "user");
-    if (role === "developer") role = "system";
-    let content = "";
-    if (typeof msg.content === "string") {
-      content = msg.content;
-    } else if (Array.isArray(msg.content)) {
-      content = msg.content.filter((c) => c.type === "text").map((c) => String(c.text || "")).join(" ");
-    }
-    content = stripInlinedImages(content);
-    const imageContext = findCachedImageContext(content);
-    if (imageContext) latestImageContext = imageContext;
-    if (!content.trim()) continue;
-    if (role === "system") {
-      systemMsg += (systemMsg ? "\n" : "") + content;
-    } else if (role === "user" || role === "assistant") {
-      history.push({ role, content });
-    }
-  }
-  let currentMsg = "";
-  if (history.length > 0 && history[history.length - 1].role === "user") {
-    currentMsg = history.pop().content;
-  }
-  return { systemMsg, history, currentMsg, latestImageContext };
-}
-const IMAGE_GEN_REGEXES = [
-  // verb + (anything within 40 chars) + image-noun
-  /\b(?:generate|create|make|draw|paint|render|produce|design|sketch|illustrate|show me)\b[\s\S]{0,40}\b(?:image|picture|photo|photograph|drawing|illustration|sketch|painting|portrait|logo|icon|art|artwork|wallpaper|render|graphic)\b/i,
-  // image-noun + "of" — "image of a kitten", "picture of mountains"
-  /\b(?:image|picture|photo|photograph|illustration|drawing|painting|render)\s+of\b/i,
-  // direct verb + a/an article — "draw a kitten", "paint an apple"
-  /\b(?:draw|paint|sketch|render|illustrate)\s+(?:me\s+)?(?:a|an|some|the)\s+\w+/i,
-  // explicit slash command users sometimes type — "/imagine ..."
-  /^\s*\/(?:image|imagine|img|draw|paint)\b/im
-];
-const OPENWEBUI_TOOL_PROMPT_MARKERS = [
-  /<chat_history>/i,
-  /^### Task:/im,
-  /\bJSON format:\s*\{/i,
-  /\bfollow_?ups\b.*\barray of strings\b/i
-];
-const OPENWEBUI_IMAGE_CONTEXT_MARKERS = [
-  /<context>\s*The requested image has been (?:created|edited and created) by the system successfully/i,
-  /<context>\s*The requested image has been edited and created and is now being shown to the user/i,
-  /<context>\s*Image generation was attempted but failed/i
-];
-function hasOpenWebUIImageContext(parsed) {
-  return OPENWEBUI_IMAGE_CONTEXT_MARKERS.some((re) => re.test(parsed.systemMsg));
-}
-function looksLikeImageGenRequest(parsed) {
-  const text = parsed.currentMsg.trim();
-  if (!text) return false;
-  if (OPENWEBUI_TOOL_PROMPT_MARKERS.some((re) => re.test(text))) return false;
-  if (hasOpenWebUIImageContext(parsed)) return false;
-  return IMAGE_GEN_REGEXES.some((re) => re.test(text));
-}
-const IMAGE_EDIT_REGEXES = [
-  /\b(?:edit|adjust|modify|change|update|alter|revise|retouch|fix)\b[\s\S]{0,120}\b(?:it|image|picture|photo|lighting|background|style|color|colour|composition|scene|time of day)\b/i,
-  /\b(?:make|turn|set|switch)\s+(?:it|the\s+(?:image|picture|photo|scene))\b[\s\S]{0,120}\b/i,
-  /\b(?:add|remove|replace)\b[\s\S]{0,120}\b(?:it|image|picture|photo|background|sky|person|object|text|logo)\b/i,
-  /\b(?:brighter|darker|night|daytime|time of day|sunset|sunrise|morning|evening|lighting|relight|background|style)\b/i,
-  /^\s*(?:now|then|also)\b[\s\S]{0,120}\b(?:make|turn|change|adjust|add|remove|replace|edit)\b/i
-];
-function looksLikeImageEditRequest(parsed) {
-  if (!parsed.latestImageContext) return false;
-  const text = parsed.currentMsg.trim();
-  if (!text) return false;
-  if (OPENWEBUI_TOOL_PROMPT_MARKERS.some((re) => re.test(text))) return false;
-  if (hasOpenWebUIImageContext(parsed)) return false;
-  return IMAGE_EDIT_REGEXES.some((re) => re.test(text));
-}
-function buildConversationBody(parsed, modelSlug, parentMessageId, options) {
-  const systemParts = [];
-  if (parsed.systemMsg.trim()) {
-    systemParts.push(parsed.systemMsg.trim());
-  }
-  const continuation = options.continuation ?? null;
-  if (!continuation && parsed.history.length > 0) {
-    const formatted = parsed.history.map((h) => `${h.role === "assistant" ? "Assistant" : "User"}: ${h.content}`).join("\n\n");
-    systemParts.push(
-      `Prior conversation (for context \u2014 answer only the new user message below):
-
-${formatted}`
-    );
-  }
-  const messages = [];
-  if (systemParts.length > 0) {
-    messages.push({
-      id: randomUUID(),
-      author: { role: "system" },
-      content: { content_type: "text", parts: [systemParts.join("\n\n")] }
-    });
-  }
-  const currentUserContent = hasOpenWebUIImageContext(parsed) ? "Briefly acknowledge the image result described in the system context. Do not generate, edit, or request another image." : parsed.currentMsg || "";
-  messages.push({
-    id: randomUUID(),
-    author: { role: "user" },
-    content: { content_type: "text", parts: [currentUserContent] }
-  });
-  return {
-    action: "next",
-    messages,
-    model: modelSlug,
-    // Text-only API-style requests start fresh because clients replay full
-    // history. Generated-image edits are the exception: ChatGPT needs the
-    // original conversation node to adjust the actual image, not just a
-    // markdown URL echoed back in a synthetic history block.
-    conversation_id: continuation?.conversationId ?? null,
-    parent_message_id: continuation?.parentMessageId ?? parentMessageId,
-    timezone_offset_min: -(/* @__PURE__ */ new Date()).getTimezoneOffset(),
-    // Temporary Chat is the default. Disable it only for image generation /
-    // image edits, where ChatGPT needs durable conversation state for tools.
-    history_and_training_disabled: !options.persistConversation,
-    suggestions: [],
-    websocket_request_id: randomUUID(),
-    conversation_mode: { kind: "primary_assistant" },
-    supports_buffering: true,
-    force_parallel_switch: "auto",
-    paragen_cot_summary_display_override: "allow",
-    ...options.thinkingEffort ? { thinking_effort: options.thinkingEffort } : {}
-  };
-}
-async function* readChatGptSseEvents(body, signal) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let dataLines = [];
-  let eventName = null;
-  function flush() {
-    if (dataLines.length === 0) {
-      eventName = null;
-      return null;
-    }
-    const payload = dataLines.join("\n");
-    dataLines = [];
-    const sseEventName = eventName;
-    eventName = null;
-    const trimmed = payload.trim();
-    if (!trimmed || trimmed === "[DONE]") return "done";
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (sseEventName && !parsed.type) parsed.type = sseEventName;
-      return parsed;
-    } catch {
-      console.warn("[chatgpt-web] stream event JSON parse failed");
-      return null;
-    }
-  }
-  try {
-    while (true) {
-      if (signal?.aborted) return;
-      const { value, done } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      while (true) {
-        const idx = buffer.indexOf("\n");
-        if (idx < 0) break;
-        const rawLine = buffer.slice(0, idx);
-        buffer = buffer.slice(idx + 1);
-        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-        if (line === "") {
-          const parsed = flush();
-          if (parsed === "done") return;
-          if (parsed) yield parsed;
-          continue;
-        }
-        if (line.startsWith("event:")) {
-          eventName = line.slice(6).trim();
-        } else if (line.startsWith("data:")) {
-          dataLines.push(line.slice(5).trimStart());
-        }
-      }
-    }
-    buffer += decoder.decode();
-    if (buffer.trim().startsWith("data:")) {
-      dataLines.push(buffer.trim().slice(5).trimStart());
-    }
-    const tail = flush();
-    if (tail && tail !== "done") yield tail;
-  } finally {
-    reader.releaseLock();
-  }
-}
-function extractImagePointers(parts) {
-  const out = [];
-  for (const p of parts) {
-    if (!p || typeof p !== "object") continue;
-    const obj = p;
-    if (obj.content_type === "image_asset_pointer" && typeof obj.asset_pointer === "string") {
-      out.push(obj.asset_pointer);
-    }
-  }
-  return out;
-}
-async function* extractContent(eventStream, signal) {
-  let conversationId = null;
-  let currentId = null;
-  let currentParts = "";
-  let emittedLen = 0;
-  let isLive = false;
-  const imagePointers = /* @__PURE__ */ new Map();
-  let imageGenAsync = false;
-  let handoff = false;
-  for await (const event of readChatGptSseEvents(eventStream, signal)) {
-    if (event.error) {
-      const msg = typeof event.error === "string" ? event.error : event.error.message || "ChatGPT stream error";
-      yield { error: msg, done: true };
-      return;
-    }
-    if (event.conversation_id) conversationId = event.conversation_id;
-    if (event.type === "stream_handoff") {
-      handoff = true;
-      yield {
-        conversationId: conversationId ?? void 0,
-        handoff: true
-      };
-      continue;
-    }
-    if (event.type === "server_ste_metadata") {
-      const meta = event.metadata;
-      if (meta && meta.turn_use_case === "image gen") {
-        imageGenAsync = true;
-      }
-    }
-    const m = event.message;
-    if (!m) continue;
-    if (m.metadata && typeof m.metadata.image_gen_task_id === "string") {
-      imageGenAsync = true;
-    }
-    if (m.author?.role !== "assistant") continue;
-    const id = m.id ?? null;
-    const status = m.status ?? "";
-    if (id && id !== currentId) {
-      currentId = id;
-      currentParts = "";
-      emittedLen = 0;
-      isLive = false;
-    }
-    if (status === "in_progress") {
-      isLive = true;
-    }
-    const parts = m.content?.parts ?? [];
-    if (parts.length === 0) continue;
-    if (status === "finished_successfully" || status === "" || isLive) {
-      for (const ptr of extractImagePointers(parts)) {
-        const existing = imagePointers.get(ptr);
-        imagePointers.set(
-          ptr,
-          existing?.messageId ? existing : { pointer: ptr, ...id ? { messageId: id } : {} }
-        );
-      }
-    }
-    const cumulative = parts.map((p) => typeof p === "string" ? p : "").join("");
-    if (cumulative.length > currentParts.length) {
-      currentParts = cumulative;
-    }
-    if (isLive && currentParts.length > emittedLen) {
-      const delta = currentParts.slice(emittedLen);
-      emittedLen = currentParts.length;
-      yield {
-        delta,
-        answer: currentParts,
-        conversationId: conversationId ?? void 0,
-        messageId: currentId ?? void 0
-      };
-    }
-  }
-  if (!isLive && currentParts.length > emittedLen) {
-    yield {
-      delta: currentParts.slice(emittedLen),
-      answer: currentParts,
-      conversationId: conversationId ?? void 0,
-      messageId: currentId ?? void 0
-    };
-  }
-  yield {
-    delta: "",
-    answer: currentParts,
-    conversationId: conversationId ?? void 0,
-    messageId: currentId ?? void 0,
-    imagePointers: imagePointers.size > 0 ? Array.from(imagePointers.values()) : void 0,
-    imageGenAsync,
-    handoff,
-    done: true
-  };
-}
-function textFromContentPart(part) {
-  if (typeof part === "string") return part;
-  if (!part || typeof part !== "object") return "";
-  const obj = part;
-  for (const key of ["text", "content", "summary"]) {
-    const value = obj[key];
-    if (typeof value === "string") return value;
-  }
-  return "";
-}
-function detailMessageText(message) {
-  const content = message.content;
-  if (!content) return "";
-  if (typeof content.text === "string") return content.text;
-  const parts = content.parts ?? [];
-  return parts.map(textFromContentPart).join("");
-}
-function extractFinalAssistantAnswer(detail) {
-  const nodes = Object.values(detail.mapping ?? {});
-  let best = null;
-  for (const node of nodes) {
-    const message = node.message;
-    if (!message || message.author?.role !== "assistant") continue;
-    if (message.metadata?.is_visually_hidden === true) continue;
-    const contentType = message.content?.content_type ?? "";
-    if (contentType.includes("thought") || contentType.includes("reasoning")) continue;
-    const text = detailMessageText(message).trim();
-    if (!text) continue;
-    const finished = message.status === "finished_successfully" && message.end_turn !== false;
-    const sort = message.update_time ?? message.create_time ?? 0;
-    if (!best || finished && (!best.finished || sort >= best.sort) || !finished && !best.finished && sort >= best.sort) {
-      best = { text, messageId: message.id, finished, sort };
-    }
-  }
-  if (!best) return null;
-  return { text: best.text, messageId: best.messageId, finished: best.finished };
-}
-function delayWithAbort(ms, signal) {
-  if (ms <= 0) return Promise.resolve();
-  if (signal?.aborted) return Promise.resolve();
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-function decodeUtf8DataUrl(text) {
-  const marker = ";base64,";
-  if (!text.startsWith("data:") || !text.includes(marker)) return text;
-  const base64 = text.slice(text.indexOf(marker) + marker.length);
-  return new TextDecoder().decode(Buffer.from(base64, "base64"));
-}
-async function fetchConversationDetail(conversationId, ctx) {
-  const url = `${CHATGPT_BASE}/backend-api/conversation/${encodeURIComponent(conversationId)}`;
-  const headers = {
-    ...browserHeaders(),
-    ...oaiHeaders(ctx.sessionId, ctx.deviceId),
-    Accept: "application/json",
-    Authorization: `Bearer ${ctx.accessToken}`,
-    Cookie: buildSessionCookieHeader(ctx.cookie)
-  };
-  if (ctx.accountId) headers["chatgpt-account-id"] = ctx.accountId;
-  try {
-    const response = await tlsFetchChatGpt(url, {
-      method: "GET",
-      headers,
-      timeoutMs: 3e4,
-      signal: ctx.signal,
-      // The native tls-client text path can surface UTF-8 JSON as mojibake
-      // (e.g. 👉 becomes 👉). Ask for raw bytes and decode as UTF-8 here so
-      // the final answer appended after Pro stream_handoff preserves Unicode.
-      byteResponse: true
-    });
-    if (response.status >= 400) {
-      ctx.log?.warn?.(
-        "CGPT-WEB",
-        `conversation poll ${response.status}: ${(response.text || "").slice(0, 300)}`
-      );
-      return { detail: null, terminal: [401, 403, 404].includes(response.status) };
-    }
-    if (!response.text) return { detail: null, terminal: false };
-    return {
-      detail: JSON.parse(decodeUtf8DataUrl(response.text)),
-      terminal: false
-    };
-  } catch (err) {
-    ctx.log?.warn?.(
-      "CGPT-WEB",
-      `conversation poll failed: ${err instanceof Error ? err.message : String(err)}`
-    );
-    return { detail: null, terminal: false };
-  }
-}
-async function pollForFinalAssistantAnswer(conversationId, ctx) {
-  const started = Date.now();
-  const timeoutMs = configuredProPollTimeoutMs();
-  const intervalMs = configuredProPollIntervalMs();
-  let last = null;
-  let terminalPollFailure = false;
-  while (!ctx.signal?.aborted && Date.now() - started < timeoutMs) {
-    const { detail, terminal } = await fetchConversationDetail(conversationId, ctx);
-    if (detail) {
-      const answer = extractFinalAssistantAnswer(detail);
-      if (answer) {
-        last = answer;
-        if (answer.finished) return answer;
-      }
-    }
-    if (terminal) {
-      terminalPollFailure = true;
-      break;
-    }
-    const remaining = timeoutMs - (Date.now() - started);
-    if (remaining <= 0) break;
-    await delayWithAbort(Math.min(intervalMs, remaining), ctx.signal);
-  }
-  if (last) {
-    ctx.log?.warn?.(
-      "CGPT-WEB",
-      terminalPollFailure ? `conversation poll stopped before finished_successfully; returning latest assistant text for ${conversationId}` : `conversation poll timed out before finished_successfully; returning latest assistant text for ${conversationId}`
-    );
-  } else {
-    ctx.log?.warn?.(
-      "CGPT-WEB",
-      terminalPollFailure ? `conversation poll stopped without assistant text for ${conversationId}` : `conversation poll timed out without assistant text for ${conversationId}`
-    );
-  }
-  return last;
-}
-function sseChunk(data) {
-  return `data: ${JSON.stringify(data)}
-
-`;
-}
-function detectImageResolutionFailure(pointerCount, resolvedCount) {
-  return pointerCount > 0 && resolvedCount === 0;
-}
-function imageMarkdown(urls) {
-  if (urls.length === 0) return "";
-  return "\n\n" + urls.map((u) => `![image](${u})`).join("\n\n");
-}
-async function resolveImagePointers(pointers, conversationId, resolver, log, fallbackParentMessageId) {
-  if (!pointers || pointers.length === 0 || !resolver) return [];
-  const urls = [];
-  for (const ref of pointers) {
-    try {
-      const url = await resolver(
-        ref.pointer,
-        conversationId,
-        ref.messageId ?? fallbackParentMessageId
-      );
-      if (url) urls.push(url);
-    } catch (err) {
-      log?.warn?.(
-        "CGPT-WEB",
-        `Image resolve failed (${ref.pointer}): ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  return urls;
-}
-function buildStreamingResponse(eventStream, model, cid, created, resolver, pollAsyncImage, pollFinalAnswer, log, signal) {
-  const encoder = new TextEncoder();
-  return new ReadableStream(
-    {
-      async start(controller) {
-        try {
-          controller.enqueue(
-            encoder.encode(
-              sseChunk({
-                id: cid,
-                object: "chat.completion.chunk",
-                created,
-                model,
-                system_fingerprint: null,
-                choices: [
-                  { index: 0, delta: { role: "assistant" }, finish_reason: null, logprobs: null }
-                ]
-              })
-            )
-          );
-          let conversationId = null;
-          let imagePointers;
-          let imageGenAsync = false;
-          let handoff = false;
-          let emittedText = "";
-          let polledFinalAnswer = "";
-          let parentCandidateMessageId = null;
-          const emitTextDelta = (content) => {
-            const cleaned = cleanChatGptText(content);
-            if (!cleaned) return;
-            emittedText += cleaned;
-            controller.enqueue(
-              encoder.encode(
-                sseChunk({
-                  id: cid,
-                  object: "chat.completion.chunk",
-                  created,
-                  model,
-                  system_fingerprint: null,
-                  choices: [
-                    {
-                      index: 0,
-                      delta: { content: cleaned },
-                      finish_reason: null,
-                      logprobs: null
-                    }
-                  ]
-                })
-              )
-            );
-          };
-          const appendFinalAnswer = (text) => {
-            const cleaned = cleanChatGptText(text);
-            const finalTrimmed = cleaned.trim();
-            if (!finalTrimmed) return;
-            const emittedTrimmed = emittedText.trim();
-            if (emittedTrimmed === finalTrimmed || emittedTrimmed.endsWith(finalTrimmed)) return;
-            const prefix = emittedTrimmed && !emittedText.endsWith("\n") ? "\n\n" : "";
-            emitTextDelta(`${prefix}${cleaned}`);
-          };
-          const startHeartbeat = (intervalMs = 5e3) => {
-            const heartbeatChunk = sseChunk({
-              id: cid,
-              object: "chat.completion.chunk",
-              created,
-              model,
-              system_fingerprint: null,
-              choices: [{ index: 0, delta: { content: "\u200B" }, finish_reason: null, logprobs: null }]
-            });
-            const timer = setInterval(() => {
-              try {
-                controller.enqueue(encoder.encode(heartbeatChunk));
-              } catch {
-                console.warn("[chatgpt-web] heartbeat enqueue failed - controller closed");
-                clearInterval(timer);
-              }
-            }, intervalMs);
-            return () => clearInterval(timer);
-          };
-          for await (const chunk of extractContent(eventStream, signal)) {
-            if (chunk.conversationId) conversationId = chunk.conversationId;
-            if (chunk.messageId) parentCandidateMessageId = chunk.messageId;
-            if (chunk.handoff) handoff = true;
-            if (chunk.error) {
-              controller.enqueue(
-                encoder.encode(
-                  sseChunk({
-                    id: cid,
-                    object: "chat.completion.chunk",
-                    created,
-                    model,
-                    system_fingerprint: null,
-                    choices: [
-                      {
-                        index: 0,
-                        delta: { content: `[Error: ${chunk.error}]` },
-                        finish_reason: null,
-                        logprobs: null
-                      }
-                    ]
-                  })
-                )
-              );
-              break;
-            }
-            if (chunk.done) {
-              imagePointers = chunk.imagePointers;
-              imageGenAsync = chunk.imageGenAsync ?? false;
-              handoff = handoff || (chunk.handoff ?? false);
-              if (chunk.messageId) parentCandidateMessageId = chunk.messageId;
-              break;
-            }
-            if (chunk.delta) {
-              emitTextDelta(chunk.delta);
-            }
-          }
-          if (pollFinalAnswer && conversationId && handoff) {
-            const stopHb = startHeartbeat();
-            try {
-              const polled = await pollFinalAnswer(conversationId);
-              if (polled?.text) {
-                polledFinalAnswer = polled.text;
-                if (polled.messageId) parentCandidateMessageId = polled.messageId;
-              }
-            } finally {
-              stopHb();
-            }
-          }
-          if (polledFinalAnswer) {
-            appendFinalAnswer(polledFinalAnswer);
-          }
-          if (imageGenAsync && conversationId && (!imagePointers || imagePointers.length === 0) && pollAsyncImage) {
-            controller.enqueue(
-              encoder.encode(
-                sseChunk({
-                  id: cid,
-                  object: "chat.completion.chunk",
-                  created,
-                  model,
-                  system_fingerprint: null,
-                  choices: [
-                    {
-                      index: 0,
-                      delta: { content: "_Generating image\u2026_\n\n" },
-                      finish_reason: null,
-                      logprobs: null
-                    }
-                  ]
-                })
-              )
-            );
-            const stopHb = startHeartbeat();
-            try {
-              const polled = await pollAsyncImage(conversationId);
-              if (polled.length > 0) imagePointers = polled;
-            } catch (err) {
-              log?.warn?.(
-                "CGPT-WEB",
-                `Async image poll failed: ${err instanceof Error ? err.message : String(err)}`
-              );
-            } finally {
-              stopHb();
-            }
-          }
-          const stopHb2 = startHeartbeat();
-          let urls = [];
-          try {
-            urls = await resolveImagePointers(
-              imagePointers,
-              conversationId,
-              resolver,
-              log,
-              parentCandidateMessageId
-            );
-          } finally {
-            stopHb2();
-          }
-          if (signal?.aborted) return;
-          const mdBlock = imageMarkdown(urls);
-          const safeEnqueue = (bytes) => {
-            try {
-              controller.enqueue(bytes);
-              return true;
-            } catch {
-              console.warn("[chatgpt-web] controller enqueue failed");
-              return false;
-            }
-          };
-          if (mdBlock) {
-            if (!safeEnqueue(
-              encoder.encode(
-                sseChunk({
-                  id: cid,
-                  object: "chat.completion.chunk",
-                  created,
-                  model,
-                  system_fingerprint: null,
-                  choices: [
-                    {
-                      index: 0,
-                      delta: { content: mdBlock },
-                      finish_reason: null,
-                      logprobs: null
-                    }
-                  ]
-                })
-              )
-            ))
-              return;
-          }
-          if (!safeEnqueue(
-            encoder.encode(
-              sseChunk({
-                id: cid,
-                object: "chat.completion.chunk",
-                created,
-                model,
-                system_fingerprint: null,
-                choices: [{ index: 0, delta: {}, finish_reason: "stop", logprobs: null }]
-              })
-            )
-          ))
-            return;
-          safeEnqueue(encoder.encode("data: [DONE]\n\n"));
-        } catch (err) {
-          controller.enqueue(
-            encoder.encode(
-              sseChunk({
-                id: cid,
-                object: "chat.completion.chunk",
-                created,
-                model,
-                system_fingerprint: null,
-                choices: [
-                  {
-                    index: 0,
-                    delta: {
-                      content: `[Stream error: ${err instanceof Error ? err.message : String(err)}]`
-                    },
-                    finish_reason: "stop",
-                    logprobs: null
-                  }
-                ]
-              })
-            )
-          );
-          controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-        } finally {
-          try {
-            controller.close();
-          } catch {
-          }
-        }
-      }
-    },
-    { highWaterMark: 16384 }
-  );
-}
-async function buildNonStreamingResponse(eventStream, model, cid, created, currentMsg, resolver, pollAsyncImage, pollFinalAnswer, log, signal) {
-  let fullAnswer = "";
-  let conversationId = null;
-  let imagePointers;
-  let imageGenAsync = false;
-  let handoff = false;
-  let parentCandidateMessageId = null;
-  for await (const chunk of extractContent(eventStream, signal)) {
-    if (chunk.conversationId) conversationId = chunk.conversationId;
-    if (chunk.messageId) parentCandidateMessageId = chunk.messageId;
-    if (chunk.handoff) handoff = true;
-    if (chunk.error) {
-      return new Response(
-        JSON.stringify({
-          error: { message: chunk.error, type: "upstream_error", code: "CHATGPT_ERROR" }
-        }),
-        { status: 502, headers: { "Content-Type": "application/json" } }
-      );
-    }
-    if (chunk.done) {
-      fullAnswer = chunk.answer || fullAnswer;
-      imagePointers = chunk.imagePointers;
-      imageGenAsync = chunk.imageGenAsync ?? false;
-      handoff = handoff || (chunk.handoff ?? false);
-      if (chunk.messageId) parentCandidateMessageId = chunk.messageId;
-      break;
-    }
-    if (chunk.answer) fullAnswer = chunk.answer;
-  }
-  if (pollFinalAnswer && conversationId && (handoff || !fullAnswer.trim())) {
-    const polled = await pollFinalAnswer(conversationId);
-    if (polled?.text) {
-      fullAnswer = polled.text;
-      if (polled.messageId) parentCandidateMessageId = polled.messageId;
-    }
-  }
-  fullAnswer = cleanChatGptText(fullAnswer);
-  if (imageGenAsync && conversationId && (!imagePointers || imagePointers.length === 0) && pollAsyncImage) {
-    try {
-      const polled = await pollAsyncImage(conversationId);
-      if (polled.length > 0) imagePointers = polled;
-    } catch (err) {
-      log?.warn?.(
-        "CGPT-WEB",
-        `Async image poll failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  const urls = await resolveImagePointers(
-    imagePointers,
-    conversationId,
-    resolver,
-    log,
-    parentCandidateMessageId
-  );
-  const imageResolutionFailed = detectImageResolutionFailure(
-    imagePointers?.length ?? 0,
-    urls.length
-  );
-  if (imageResolutionFailed && log?.warn) {
-    const schemes = (imagePointers ?? []).map((p) => p.pointer.split("://")[0] || p.pointer.slice(0, 24)).join(", ");
-    log.warn(
-      "CGPT-WEB",
-      `Image generated upstream but no asset pointer resolved (schemes: ${schemes}) \u2014 surfacing as unretrievable`
-    );
-  }
-  fullAnswer += imageMarkdown(urls);
-  const promptTokens = Math.ceil(currentMsg.length / 4);
-  const completionTokens = Math.ceil(fullAnswer.length / 4);
-  return new Response(
-    JSON.stringify({
-      id: cid,
-      object: "chat.completion",
-      created,
-      model,
-      system_fingerprint: null,
-      ...imageResolutionFailed ? { x_image_resolution_failed: true } : {},
-      choices: [
-        {
-          index: 0,
-          message: { role: "assistant", content: fullAnswer },
-          finish_reason: "stop",
-          logprobs: null
-        }
-      ],
-      usage: {
-        prompt_tokens: promptTokens,
-        completion_tokens: completionTokens,
-        total_tokens: promptTokens + completionTokens
-      }
-    }),
-    { status: 200, headers: { "Content-Type": "application/json" } }
-  );
-}
-function errorResponse(status, message, code) {
-  return new Response(
-    JSON.stringify({ error: { message, type: "upstream_error", ...code ? { code } : {} } }),
-    { status, headers: { "Content-Type": "application/json" } }
-  );
-}
-function normalizePublicBaseUrl(value) {
-  const trimmed = value?.trim();
-  if (!trimmed) return null;
-  return trimmed.replace(/\/+$/, "").replace(/\/v1$/i, "");
-}
-function firstForwardedValue(value) {
-  const first = value?.split(",")[0]?.trim();
-  return first || null;
-}
-function isLocalBaseUrl(baseUrl) {
-  try {
-    const host = new URL(baseUrl).hostname.toLowerCase();
-    return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "0.0.0.0";
-  } catch {
-    console.warn("[chatgpt-web] URL parse failed, falling back to regex");
-    return /\b(?:localhost|127\.0\.0\.1|0\.0\.0\.0)\b/i.test(baseUrl);
-  }
-}
-function deriveHeaderBaseUrl(clientHeaders) {
-  const headers = clientHeaders ?? {};
-  const lower = {};
-  for (const [k, v] of Object.entries(headers)) lower[k.toLowerCase()] = v;
-  const forwardedHost = firstForwardedValue(lower["x-forwarded-host"]);
-  const forwardedProto = firstForwardedValue(lower["x-forwarded-proto"]);
-  const host = forwardedHost || firstForwardedValue(lower["host"]);
-  if (!host) return null;
-  const isPlain = host.includes("localhost") || /^\d+\.\d+\.\d+\.\d+(:\d+)?$/.test(host) || host.endsWith(".local") || host.includes(":");
-  const proto = forwardedProto || (isPlain ? "http" : "https");
-  return `${proto}://${host}`;
-}
-function derivePublicBaseUrl(clientHeaders, log) {
-  const explicitPublicBase = normalizePublicBaseUrl(process.env.OMNIROUTE_PUBLIC_BASE_URL);
-  if (explicitPublicBase) {
-    log?.debug?.("CGPT-WEB", `derivePublicBaseUrl: using OMNIROUTE_PUBLIC_BASE_URL`);
-    return explicitPublicBase;
-  }
-  const headerBase = deriveHeaderBaseUrl(clientHeaders);
-  const configuredBase = normalizePublicBaseUrl(process.env.OMNIROUTE_BASE_URL) || normalizePublicBaseUrl(process.env.NEXT_PUBLIC_BASE_URL);
-  log?.debug?.(
-    "CGPT-WEB",
-    `derivePublicBaseUrl: configured=${configuredBase ?? "-"} header=${headerBase ?? "-"}`
-  );
-  if (configuredBase && (!headerBase || !isLocalBaseUrl(configuredBase))) return configuredBase;
-  if (headerBase) return headerBase;
-  if (configuredBase) return configuredBase;
-  return `http://localhost:${process.env.PORT || 20128}`;
-}
-const FILE_SERVICE_PREFIX = "file-service://";
-const SEDIMENT_PREFIX = "sediment://";
-async function fetchDownloadUrl(endpoint, ctx) {
-  const headers = {
-    ...browserHeaders(),
-    ...oaiHeaders(ctx.sessionId, ctx.deviceId),
-    Accept: "application/json",
-    Authorization: `Bearer ${ctx.accessToken}`,
-    Cookie: buildSessionCookieHeader(ctx.cookie)
-  };
-  if (ctx.accountId) headers["chatgpt-account-id"] = ctx.accountId;
-  const response = await tlsFetchChatGpt(endpoint, {
-    method: "GET",
-    headers,
-    timeoutMs: 3e4,
-    signal: ctx.signal
-  });
-  if (response.status !== 200) {
-    ctx.log?.warn?.(
-      "CGPT-WEB",
-      `Image download URL fetch failed (${response.status}) for ${endpoint}`
-    );
-    return null;
-  }
-  let parsed = {};
-  try {
-    parsed = JSON.parse(response.text || "{}");
-  } catch {
-    console.warn("[chatgpt-web] image download URL parse failed");
-    return null;
-  }
-  return parsed.download_url ?? null;
-}
-const IMAGE_DOWNLOAD_MAX_BYTES = 8 * 1024 * 1024;
-async function imageUrlToCachedImageUrl(signedUrl, ctx, imageContext) {
-  const headers = {
-    ...browserHeaders(),
-    Accept: "image/*,*/*;q=0.8",
-    Authorization: `Bearer ${ctx.accessToken}`,
-    Cookie: buildSessionCookieHeader(ctx.cookie)
-  };
-  if (ctx.accountId) headers["chatgpt-account-id"] = ctx.accountId;
-  let response;
-  try {
-    response = await tlsFetchChatGpt(signedUrl, {
-      method: "GET",
-      headers,
-      timeoutMs: 6e4,
-      signal: ctx.signal,
-      // Required for binary payloads — the underlying tls-client returns
-      // bytes as a `data:<mime>;base64,...` string when this is true.
-      // Without it, raw image bytes get mangled by UTF-8 decoding.
-      byteResponse: true
-    });
-  } catch (err) {
-    ctx.log?.warn?.(
-      "CGPT-WEB",
-      `Image fetch failed: ${err instanceof Error ? err.message : String(err)}`
-    );
-    return null;
-  }
-  if (response.status !== 200) {
-    ctx.log?.warn?.(
-      "CGPT-WEB",
-      `Image fetch returned HTTP ${response.status} (${(response.text || "").slice(0, 120)})`
-    );
-    return null;
-  }
-  if (response.text == null || response.text.length === 0) return null;
-  let bytes;
-  let mime;
-  if (/^data:[^;]{1,256};base64,/.test(response.text)) {
-    const commaIdx = response.text.indexOf(",");
-    const header = response.text.slice(5, commaIdx);
-    mime = header.split(";")[0] || "image/png";
-    bytes = Buffer.from(response.text.slice(commaIdx + 1), "base64");
-  } else {
-    bytes = Buffer.from(response.text, "binary");
-    mime = response.headers.get("content-type")?.split(";")[0]?.trim() || "image/png";
-  }
-  if (bytes.length === 0 || bytes.length > IMAGE_DOWNLOAD_MAX_BYTES) {
-    if (bytes.length > IMAGE_DOWNLOAD_MAX_BYTES) {
-      ctx.log?.warn?.(
-        "CGPT-WEB",
-        `Image too large to cache (${bytes.length} bytes > ${IMAGE_DOWNLOAD_MAX_BYTES}); skipping`
-      );
-    }
-    return null;
-  }
-  const id = storeChatGptImage(bytes, mime, void 0, imageContext);
-  return `${ctx.publicBaseUrl}/v1/chatgpt-web/image/${id}`;
-}
-async function registerWebSocket(ctx) {
-  const candidates = [
-    { url: `${CHATGPT_BASE}/backend-api/celsius/ws/user`, method: "GET" },
-    { url: `${CHATGPT_BASE}/backend-api/register-websocket`, method: "POST" }
-  ];
-  const headers = {
-    ...browserHeaders(),
-    ...oaiHeaders(ctx.sessionId, ctx.deviceId),
-    Accept: "application/json",
-    Authorization: `Bearer ${ctx.accessToken}`,
-    Cookie: buildSessionCookieHeader(ctx.cookie)
-  };
-  if (ctx.accountId) headers["chatgpt-account-id"] = ctx.accountId;
-  for (const { url, method } of candidates) {
-    let r;
-    try {
-      r = await tlsFetchChatGpt(url, {
-        method,
-        headers,
-        body: method === "POST" ? "" : void 0,
-        timeoutMs: 3e4,
-        signal: ctx.signal
-      });
-    } catch (err) {
-      ctx.log?.warn?.(
-        "CGPT-WEB",
-        `register-websocket fetch failed for ${url}: ${err instanceof Error ? err.message : String(err)}`
-      );
-      continue;
-    }
-    if (r.status === 200) {
-      try {
-        const data = JSON.parse(r.text || "{}");
-        const ws = data.websocket_url ?? data.wss_url;
-        if (ws) {
-          ctx.log?.debug?.("CGPT-WEB", `Got WebSocket URL via ${url}`);
-          return ws;
-        }
-      } catch {
-        console.warn("[chatgpt-web] WebSocket URL parse failed, falling through");
-      }
-    }
-    ctx.log?.warn?.(
-      "CGPT-WEB",
-      `register-websocket via ${url} \u2192 ${r.status}: ${(r.text || "").slice(0, 200)}`
-    );
-  }
-  return null;
-}
-async function waitForImageViaWebSocket(wssUrl, conversationId, timeoutMs, ctx) {
-  return new Promise((resolve) => {
-    const found = /* @__PURE__ */ new Map();
-    let resolved = false;
-    let errored = false;
-    let gotAnyMessage = false;
-    const finish = () => {
-      if (resolved) return;
-      resolved = true;
-      try {
-        ws.close();
-      } catch {
-        console.warn("[chatgpt-web] ws.close failed");
-      }
-      resolve({
-        pointers: Array.from(found.values()),
-        errored,
-        gotAnyMessage
-      });
-    };
-    const ws = new WebSocket(wssUrl);
-    const timer = setTimeout(() => {
-      ctx.log?.warn?.("CGPT-WEB", `WebSocket image wait timed out after ${timeoutMs}ms`);
-      finish();
-    }, timeoutMs);
-    const onAbort = () => {
-      ctx.log?.debug?.("CGPT-WEB", "WebSocket aborted by client");
-      finish();
-    };
-    ctx.signal?.addEventListener?.("abort", onAbort);
-    ws.onopen = () => {
-      gotAnyMessage = true;
-      ctx.log?.debug?.("CGPT-WEB", "WebSocket open \u2014 waiting for image events");
-    };
-    ws.onerror = (e) => {
-      errored = true;
-      ctx.log?.warn?.("CGPT-WEB", `WebSocket error: ${e.message ?? "unknown"}`);
-    };
-    ws.onclose = () => {
-      clearTimeout(timer);
-      ctx.signal?.removeEventListener?.("abort", onAbort);
-      finish();
-    };
-    ws.onmessage = (event) => {
-      gotAnyMessage = true;
-      let payload;
-      const raw = typeof event.data === "string" ? event.data : event.data.toString();
-      try {
-        payload = JSON.parse(raw);
-      } catch {
-        console.warn("[chatgpt-web] WebSocket event JSON parse failed");
-        return;
-      }
-      const obj = payload;
-      const candidates = [];
-      const innerPayload = obj.payload;
-      const updateContent = innerPayload?.update_content;
-      if (updateContent?.message) {
-        candidates.push({
-          message: updateContent.message,
-          conversation_id: innerPayload?.conversation_id
-        });
-      }
-      if (innerPayload?.message) {
-        candidates.push({
-          message: innerPayload.message,
-          conversation_id: innerPayload.conversation_id
-        });
-      }
-      if (obj.data?.message) {
-        candidates.push(obj.data);
-      }
-      for (const data of candidates) {
-        if (data?.conversation_id && data.conversation_id !== conversationId) continue;
-        const m = data?.message;
-        if (Array.isArray(m?.content?.parts)) {
-          for (const ptr of extractImagePointers(m.content?.parts ?? [])) {
-            const existing = found.get(ptr);
-            found.set(
-              ptr,
-              existing?.messageId ? existing : { pointer: ptr, ...m?.id ? { messageId: m.id } : {} }
-            );
-          }
-        }
-        if (m?.metadata && typeof m.metadata === "object") {
-          const md = m.metadata;
-          const ptr = md.asset_pointer ?? md.image_asset_pointer;
-          if (typeof ptr === "string") {
-            const existing = found.get(ptr);
-            found.set(
-              ptr,
-              existing?.messageId ? existing : { pointer: ptr, ...m?.id ? { messageId: m.id } : {} }
-            );
-          }
-        }
-      }
-      if (found.size > 0) finish();
-    };
-  });
-}
-const DEFAULT_ASYNC_IMAGE_TIMEOUT_MS = 18e4;
-function configuredAsyncImageTimeoutMs() {
-  const raw = Number(process.env.OMNIROUTE_CGPT_WEB_IMAGE_TIMEOUT_MS);
-  if (!Number.isFinite(raw) || raw <= 0) return DEFAULT_ASYNC_IMAGE_TIMEOUT_MS;
-  return Math.floor(raw);
-}
-async function pollForAsyncImage(conversationId, ctx, opts = {}) {
-  const totalTimeoutMs = opts.timeoutMs ?? configuredAsyncImageTimeoutMs();
-  const deadline = Date.now() + totalTimeoutMs;
-  for (let attempt = 0; attempt < 2; attempt++) {
-    const remaining = deadline - Date.now();
-    if (remaining <= 0) break;
-    const wssUrl = await registerWebSocket(ctx);
-    if (!wssUrl) {
-      ctx.log?.warn?.(
-        "CGPT-WEB",
-        attempt === 0 ? "Could not register WebSocket \u2014 async image gen not retrievable" : `WebSocket re-registration failed on retry attempt ${attempt + 1}`
-      );
-      if (attempt === 0) continue;
-      return [];
-    }
-    ctx.log?.debug?.(
-      "CGPT-WEB",
-      `Registered WebSocket for async image (attempt ${attempt + 1}, ${remaining}ms remaining)`
-    );
-    const outcome = await waitForImageViaWebSocket(wssUrl, conversationId, remaining, ctx);
-    if (outcome.pointers.length > 0) return outcome.pointers;
-    if (ctx.signal?.aborted) return [];
-    if (!outcome.errored || outcome.gotAnyMessage) return [];
-    ctx.log?.warn?.(
-      "CGPT-WEB",
-      `WebSocket attempt ${attempt + 1} ended in transport error before any frame; retrying`
-    );
-  }
-  return [];
-}
-function makeImageResolver(ctx) {
-  const cache = /* @__PURE__ */ new Map();
-  return async (assetPointer, conversationId, parentMessageId) => {
-    if (cache.has(assetPointer)) return cache.get(assetPointer) ?? null;
-    let fileId = null;
-    if (assetPointer.startsWith(FILE_SERVICE_PREFIX)) {
-      fileId = assetPointer.slice(FILE_SERVICE_PREFIX.length);
-    } else if (assetPointer.startsWith(SEDIMENT_PREFIX)) {
-      fileId = assetPointer.slice(SEDIMENT_PREFIX.length);
-    } else {
-      ctx.log?.warn?.("CGPT-WEB", `Unknown asset_pointer scheme: ${assetPointer}`);
-    }
-    let signedUrl = null;
-    if (fileId) {
-      signedUrl = await fetchDownloadUrl(
-        `${CHATGPT_BASE}/backend-api/files/${encodeURIComponent(fileId)}/download`,
-        ctx
-      );
-      if (!signedUrl && conversationId) {
-        signedUrl = await fetchDownloadUrl(
-          `${CHATGPT_BASE}/backend-api/conversation/${encodeURIComponent(conversationId)}/attachment/${encodeURIComponent(fileId)}/download`,
-          ctx
-        );
-      }
-    }
-    let finalUrl = null;
-    if (signedUrl) {
-      finalUrl = await imageUrlToCachedImageUrl(
-        signedUrl,
-        ctx,
-        conversationId && parentMessageId ? { conversationId, parentMessageId } : void 0
-      );
-    }
-    cache.set(assetPointer, finalUrl);
-    if (finalUrl) {
-      const preview = finalUrl.startsWith("data:") ? `data:... (${finalUrl.length} chars)` : finalUrl.slice(0, 80) + "...";
-      ctx.log?.debug?.("CGPT-WEB", `Resolved ${assetPointer} \u2192 ${preview}`);
-    }
-    return finalUrl;
-  };
-}
-class ChatGptWebExecutor extends BaseExecutor {
-  constructor() {
-    super("chatgpt-web", { id: "chatgpt-web", baseUrl: CONV_URL });
-  }
-  async execute({
-    model,
-    body,
-    stream,
-    credentials,
-    signal,
-    log,
-    onCredentialsRefreshed,
-    clientHeaders
-  }) {
-    const messages = body?.messages;
-    if (!messages || !Array.isArray(messages) || messages.length === 0) {
-      return {
-        response: errorResponse(400, "Missing or empty messages array"),
-        url: CONV_URL,
-        headers: {},
-        transformedBody: body
-      };
-    }
-    const { hasTools, requestedTools, effectiveMessages } = prepareToolMessages(
-      body || {},
-      messages
-    );
-    if (!credentials.apiKey) {
-      return {
-        response: errorResponse(
-          401,
-          "ChatGPT auth failed \u2014 paste your __Secure-next-auth.session-token cookie value."
-        ),
-        url: CONV_URL,
-        headers: {},
-        transformedBody: body
-      };
-    }
-    const cookie = credentials.apiKey;
-    let tokenEntry;
-    try {
-      tokenEntry = await exchangeSession(cookie, signal);
-    } catch (err) {
-      if (err instanceof SessionAuthError) {
-        log?.warn?.("CGPT-WEB", err.message);
-        return {
-          response: errorResponse(
-            401,
-            "ChatGPT auth failed \u2014 re-paste your __Secure-next-auth.session-token cookie from chatgpt.com.",
-            "HTTP_401"
-          ),
-          url: SESSION_URL,
-          headers: {},
-          transformedBody: body
-        };
-      }
-      log?.error?.(
-        "CGPT-WEB",
-        `Session exchange failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-      return {
-        response: errorResponse(
-          502,
-          `ChatGPT session exchange failed: ${err instanceof Error ? err.message : String(err)}`
-        ),
-        url: SESSION_URL,
-        headers: {},
-        transformedBody: body
-      };
-    }
-    if (tokenEntry.refreshedCookie && tokenEntry.refreshedCookie !== cookie) {
-      const updated = { ...credentials, apiKey: tokenEntry.refreshedCookie };
-      try {
-        await onCredentialsRefreshed?.(updated);
-      } catch (err) {
-        log?.warn?.(
-          "CGPT-WEB",
-          `Failed to persist refreshed cookie: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    let dplInfo;
-    try {
-      dplInfo = await fetchDpl(cookie, signal);
-    } catch (err) {
-      log?.warn?.(
-        "CGPT-WEB",
-        `DPL warmup failed (continuing with fallback): ${err instanceof Error ? err.message : String(err)}`
-      );
-      dplInfo = {
-        dpl: `dpl=${OAI_CLIENT_VERSION.replace(/^prod-/, "")}`,
-        scriptSrc: `${CHATGPT_BASE}/_next/static/chunks/webpack-${randomHex(16)}.js`
-      };
-    }
-    const sessionId = randomUUID();
-    const deviceId = deviceIdFor(cookie);
-    await runSessionWarmup(
-      tokenEntry.accessToken,
-      tokenEntry.accountId,
-      sessionId,
-      deviceId,
-      cookie,
-      signal,
-      log
-    );
-    const resolvedModel = resolveChatGptModel(model, body, credentials.providerSpecificData);
-    const modelSlug = resolvedModel.slug;
-    const requestedEffort = resolvedModel.effort;
-    if (requestedEffort && isThinkingCapableModel(model, modelSlug)) {
-      await setUserThinkingEffort(
-        modelSlug,
-        requestedEffort,
-        tokenEntry.accessToken,
-        tokenEntry.accountId,
-        sessionId,
-        deviceId,
-        cookie,
-        signal,
-        log
-      );
-    }
-    let reqs;
-    try {
-      reqs = await prepareChatRequirements(
-        tokenEntry.accessToken,
-        tokenEntry.accountId,
-        sessionId,
-        deviceId,
-        cookie,
-        dplInfo,
-        signal,
-        log
-      );
-    } catch (err) {
-      if (err instanceof SentinelBlockedError) {
-        log?.warn?.("CGPT-WEB", err.message);
-        return {
-          response: errorResponse(
-            403,
-            "ChatGPT blocked the request (Sentinel/Turnstile required). Try again later or open chatgpt.com in a browser to refresh state.",
-            "SENTINEL_BLOCKED"
-          ),
-          url: SENTINEL_PREPARE_URL,
-          headers: {},
-          transformedBody: body
-        };
-      }
-      log?.error?.(
-        "CGPT-WEB",
-        `Sentinel failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-      return {
-        response: errorResponse(
-          502,
-          `ChatGPT sentinel failed: ${err instanceof Error ? err.message : String(err)}`
-        ),
-        url: SENTINEL_PREPARE_URL,
-        headers: {},
-        transformedBody: body
-      };
-    }
-    log?.debug?.(
-      "CGPT-WEB",
-      `sentinel: token=${reqs.token ? "y" : "n"} pow=${reqs.proofofwork?.required ? "y" : "n"} turnstile=${reqs.turnstile?.required ? "y" : "n"}`
-    );
-    const turnstileToken = typeof credentials.providerSpecificData?.turnstileToken === "string" ? credentials.providerSpecificData.turnstileToken : null;
-    let proofToken = null;
-    if (reqs.proofofwork?.required && reqs.proofofwork.seed && reqs.proofofwork.difficulty) {
-      const powConfig = buildPrekeyConfig(CHATGPT_USER_AGENT, dplInfo.dpl, dplInfo.scriptSrc);
-      proofToken = await solveProofOfWork(
-        reqs.proofofwork.seed,
-        reqs.proofofwork.difficulty,
-        powConfig,
-        log
-      );
-    }
-    const parsed = parseOpenAIMessages(effectiveMessages);
-    if (!parsed.currentMsg.trim() && parsed.history.length === 0) {
-      return {
-        response: errorResponse(400, "Empty user message"),
-        url: CONV_URL,
-        headers: {},
-        transformedBody: body
-      };
-    }
-    const imageEdit = looksLikeImageEditRequest(parsed);
-    const continuation = imageEdit ? parsed.latestImageContext : null;
-    const forImageGen = looksLikeImageGenRequest(parsed) || imageEdit;
-    const persistConversation = forImageGen || !!continuation;
-    if (forImageGen) {
-      log?.debug?.(
-        "CGPT-WEB",
-        continuation ? "Image edit intent detected \u2014 continuing saved image conversation" : "Image-gen intent detected \u2014 disabling Temporary Chat for this turn"
-      );
-    } else if (resolvedModel.isPro) {
-      log?.debug?.("CGPT-WEB", "GPT-5.5 Pro text request \u2014 keeping Temporary Chat enabled");
-    }
-    const parentMessageId = continuation?.parentMessageId ?? randomUUID();
-    const cgptBody = buildConversationBody(parsed, modelSlug, parentMessageId, {
-      persistConversation,
-      thinkingEffort: requestedEffort,
-      continuation
-    });
-    const headers = {
-      ...browserHeaders(),
-      ...oaiHeaders(sessionId, deviceId),
-      "Content-Type": "application/json",
-      Accept: "text/event-stream",
-      Authorization: `Bearer ${tokenEntry.accessToken}`,
-      Cookie: buildSessionCookieHeader(cookie)
-    };
-    if (tokenEntry.accountId) headers["chatgpt-account-id"] = tokenEntry.accountId;
-    if (reqs.token) headers["openai-sentinel-chat-requirements-token"] = reqs.token;
-    if (reqs.prepare_token)
-      headers["openai-sentinel-chat-requirements-prepare-token"] = reqs.prepare_token;
-    if (proofToken) headers["openai-sentinel-proof-token"] = proofToken;
-    if (turnstileToken) headers["openai-sentinel-turnstile-token"] = turnstileToken;
-    log?.info?.("CGPT-WEB", `Conversation request \u2192 ${modelSlug} (pow=${!!proofToken})`);
-    let response;
-    try {
-      response = await tlsFetchChatGpt(CONV_URL, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(cgptBody),
-        timeoutMs: 12e4,
-        // generations can take a while
-        signal,
-        // For real-time streaming, ask the TLS client to write the body to
-        // a temp file and surface it as a ReadableStream as it arrives —
-        // otherwise long generations buffer entirely before the client sees
-        // anything (and the downstream HTTP request can time out).
-        stream
-      });
-    } catch (err) {
-      log?.error?.("CGPT-WEB", `Fetch failed: ${err instanceof Error ? err.message : String(err)}`);
-      const code = err instanceof TlsClientUnavailableError ? "TLS_UNAVAILABLE" : void 0;
-      return {
-        response: errorResponse(
-          502,
-          `ChatGPT connection failed: ${err instanceof Error ? err.message : String(err)}`,
-          code
-        ),
-        url: CONV_URL,
-        headers,
-        transformedBody: cgptBody
-      };
-    }
-    if (response.status >= 400) {
-      const status = response.status;
-      log?.warn?.("CGPT-WEB", `conv ${status}: ${(response.text || "").slice(0, 400)}`);
-      const errMsg = describeChatGptWebHttpError(status);
-      if (status === 401 || status === 403) {
-        tokenCache.delete(cookieKey(cookie));
-      }
-      log?.warn?.("CGPT-WEB", errMsg);
-      return {
-        response: errorResponse(status, errMsg, `HTTP_${status}`),
-        url: CONV_URL,
-        headers,
-        transformedBody: cgptBody
-      };
-    }
-    let bodyStream;
-    if (response.body) {
-      bodyStream = response.body;
-    } else if (response.text) {
-      bodyStream = stringToStream(response.text);
-    } else {
-      return {
-        response: errorResponse(502, "ChatGPT returned empty response body"),
-        url: CONV_URL,
-        headers,
-        transformedBody: cgptBody
-      };
-    }
-    const cid = `chatcmpl-cgpt-${crypto.randomUUID().slice(0, 12)}`;
-    const created = Math.floor(Date.now() / 1e3);
-    const resolverCtx = {
-      accessToken: tokenEntry.accessToken,
-      accountId: tokenEntry.accountId,
-      sessionId,
-      deviceId,
-      cookie,
-      signal,
-      log,
-      publicBaseUrl: derivePublicBaseUrl(clientHeaders, log)
-    };
-    const imageResolver = makeImageResolver(resolverCtx);
-    const pollAsyncImage = (conversationId) => pollForAsyncImage(conversationId, resolverCtx);
-    const pollFinalAnswer = resolvedModel.isPro ? (conversationId) => pollForFinalAssistantAnswer(conversationId, resolverCtx) : null;
-    const toolMode = hasTools && !forImageGen;
-    let finalResponse;
-    if (stream && !toolMode) {
-      const sseStream = buildStreamingResponse(
-        bodyStream,
-        model,
-        cid,
-        created,
-        imageResolver,
-        pollAsyncImage,
-        pollFinalAnswer,
-        log,
-        signal
-      );
-      finalResponse = new Response(sseStream, {
-        status: 200,
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          "X-Accel-Buffering": "no"
-        }
-      });
-    } else {
-      finalResponse = await buildNonStreamingResponse(
-        bodyStream,
-        model,
-        cid,
-        created,
-        parsed.currentMsg,
-        imageResolver,
-        pollAsyncImage,
-        pollFinalAnswer,
-        log,
-        signal
-      );
-      if (toolMode) {
-        finalResponse = await buildToolModeResponse(finalResponse, requestedTools, stream, {
-          cid,
-          created,
-          model
-        });
-      }
-    }
-    return { response: finalResponse, url: CONV_URL, headers, transformedBody: cgptBody };
-  }
-}
-const ENTITY_RE = /entity\["[^"]*","([^"]*)"[^\]]*\]/g;
-function cleanChatGptText(text) {
-  return text.replace(ENTITY_RE, "$1");
-}
-function stringToStream(text) {
-  const encoder = new TextEncoder();
-  return new ReadableStream({
-    start(controller) {
-      controller.enqueue(encoder.encode(text));
-      controller.close();
-    }
-  });
-}
-function __resetChatGptWebCachesForTesting() {
-  tokenCache.clear();
-  warmupCache.clear();
-  thinkingEffortCache.clear();
-  deviceIdCache.clear();
-  __resetChatGptImageCacheForTesting();
-  dplCache = null;
-}
-const __derivePublicBaseUrlForTesting = derivePublicBaseUrl;
-export {
-  ChatGptWebExecutor,
-  __derivePublicBaseUrlForTesting,
-  __resetChatGptWebCachesForTesting,
-  detectImageResolutionFailure
-};