@fudrouter/fsrouter 0.6.61 → 0.6.63

package/open-sse/executors/gemini-business.js

@@ -0,0 +1,320 @@
+import { createHash, randomUUID } from "node:crypto";
+import { BaseExecutor } from "./base.ts";
+import { makeExecutorErrorResult as makeErrorResult } from "../utils/error.js";
+const GEMINI_BUSINESS_FETCH_TIMEOUT_MS = 6e4;
+const GEMINI_BUSINESS_USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36";
+const DEFAULT_ENTRY_URL = "https://business.gemini.google/home";
+const MODEL_CATEGORY_MAP = {
+  // Gemini 3.x (enterprise)
+  "gemini-3-pro": 70,
+  "gemini-3-ultra": 71,
+  "gemini-3-flash": 75,
+  // Gemini 2.5 (enterprise)
+  "gemini-2.5-pro": 53,
+  "gemini-2.5-flash": 54,
+  "gemini-2.5-flash-thinking": 55,
+  // Gemini 2.0
+  "gemini-2.0-pro": 51,
+  "gemini-2.0-flash": 52,
+  "gemini-2.0-flash-thinking": 56,
+  // Image / video
+  "gemini-3-pro-image": 76,
+  "gemini-2.0-flash-image": 57,
+  "veo-3.1-generate": 80
+};
+const DEFAULT_MODEL = "gemini-2.5-pro";
+const DEFAULT_MODEL_CATEGORY = 53;
+class GeminiBusinessExecutor extends BaseExecutor {
+  constructor() {
+    super("gemini-business", { id: "gemini-business", baseUrl: DEFAULT_ENTRY_URL });
+  }
+  async execute(input) {
+    const { model, body, stream: wantStream, credentials, signal } = input;
+    const requestBody = body;
+    const directCookie = readCredentialString(credentials?.apiKey) || readCredentialString(credentials?.cookie);
+    const psid = readProviderSpecificString(credentials?.providerSpecificData, [
+      "__Secure-1PSID",
+      "cookie"
+    ]);
+    const psidts = readProviderSpecificString(credentials?.providerSpecificData, [
+      "__Secure-1PSIDTS"
+    ]);
+    const cookie = directCookie || [psid, psidts].filter(Boolean).join("; ");
+    if (!cookie) {
+      return makeErrorResult(
+        401,
+        "Missing Gemini Business cookies. Set __Secure-1PSID and __Secure-1PSIDTS from your enterprise account (business.gemini.google).",
+        body,
+        DEFAULT_ENTRY_URL
+      );
+    }
+    const entryUrl = readProviderSpecificString(credentials?.providerSpecificData, ["entryUrl", "entry_url"]) || DEFAULT_ENTRY_URL;
+    const { baseOrigin, pathPrefix } = parseEntryUrl(entryUrl);
+    const messages = requestBody.messages || [];
+    const lastUserMsg = messages.filter((m) => m.role === "user").pop();
+    const prompt = extractTextContent(lastUserMsg?.content);
+    if (!prompt) {
+      return makeErrorResult(
+        400,
+        "No user message found in request body.",
+        body,
+        DEFAULT_ENTRY_URL
+      );
+    }
+    const requestedModel = model || DEFAULT_MODEL;
+    const modelCategory = MODEL_CATEGORY_MAP[requestedModel] ?? DEFAULT_MODEL_CATEGORY;
+    const innerArray = buildInnerArray(prompt, modelCategory);
+    const streamUrl = `${baseOrigin}${pathPrefix}/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate?bl=boq_assistant-bard-web-server_20240619.16_p0&hl=en&_reqid=${Math.floor(Math.random() * 9e5) + 1e5}&rt=c`;
+    const formBody = new URLSearchParams();
+    formBody.set("f.req", JSON.stringify([null, JSON.stringify(innerArray)]));
+    const headers = {
+      "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+      Accept: "*/*",
+      "Accept-Language": "en-US,en;q=0.9",
+      Cookie: cookie,
+      "X-Same-Domain": "1",
+      "User-Agent": GEMINI_BUSINESS_USER_AGENT,
+      Origin: baseOrigin,
+      Referer: `${baseOrigin}${pathPrefix}/`
+    };
+    const sapisid = extractCookieValue(cookie, "SAPISID") || extractCookieValue(cookie, "__Secure-3PAPISID");
+    if (sapisid) {
+      headers["Authorization"] = computeSapisidHash(sapisid, baseOrigin);
+    }
+    let response;
+    try {
+      response = await fetch(streamUrl, {
+        method: "POST",
+        headers,
+        body: formBody.toString(),
+        signal: combineAbortSignals(signal, AbortSignal.timeout(GEMINI_BUSINESS_FETCH_TIMEOUT_MS))
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "fetch failed";
+      const isTimeout = err instanceof Error && err.name === "TimeoutError";
+      return makeErrorResult(
+        isTimeout ? 504 : 502,
+        `Gemini Business ${isTimeout ? "request timed out" : "network error"}: ${message}`,
+        body,
+        streamUrl
+      );
+    }
+    if (!response.ok) {
+      const text2 = await response.text().catch(() => "");
+      return makeErrorResult(
+        response.status,
+        `Gemini Business returned HTTP ${response.status}: ${text2.slice(0, 200)}`,
+        body,
+        streamUrl
+      );
+    }
+    const rawText = await response.text();
+    if (rawText.includes("auth.business.gemini.google/account-chooser")) {
+      return makeErrorResult(
+        403,
+        "Gemini Business account-chooser detected. Your enterprise cookies may be stale or the entry URL is wrong. Re-extract __Secure-1PSID/PSIDTS from business.gemini.google/home/cid/{YOUR-CID} after signing in.",
+        body,
+        streamUrl
+      );
+    }
+    const text = parseStreamResponse(rawText);
+    if (!text) {
+      return makeErrorResult(
+        502,
+        "Gemini Business returned no text. The cookie may be expired or the entry URL is wrong.",
+        body,
+        streamUrl
+      );
+    }
+    if (wantStream) {
+      return {
+        response: buildStreamingResponse(text, requestedModel),
+        url: streamUrl,
+        headers: {},
+        transformedBody: body
+      };
+    }
+    return {
+      response: buildJsonResponse(text, requestedModel),
+      url: streamUrl,
+      headers: {},
+      transformedBody: body
+    };
+  }
+}
+function buildInnerArray(prompt, modelCategory) {
+  const inner = new Array(80).fill(null);
+  inner[0] = [prompt, 0, null, null, null, null, 0];
+  inner[1] = ["en"];
+  inner[2] = ["", "", "", null, null, null, null, null, null, ""];
+  inner[6] = [0];
+  inner[7] = 1;
+  inner[10] = 1;
+  inner[11] = 0;
+  inner[17] = [[0]];
+  inner[18] = 0;
+  inner[27] = 1;
+  inner[30] = [4];
+  inner[41] = [2];
+  inner[53] = 0;
+  inner[59] = randomUUID();
+  inner[61] = [];
+  inner[68] = 1;
+  inner[79] = modelCategory;
+  return inner;
+}
+function parseStreamResponse(raw) {
+  const lines = raw.split("\n");
+  const textChunks = [];
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line === ")]}'" || /^\d+$/.test(line)) continue;
+    if (!line.includes("wrb.fr")) continue;
+    try {
+      const arr = JSON.parse(line);
+      if (!Array.isArray(arr) || !arr[0] || arr[0][0] !== "wrb.fr") continue;
+      const payload = arr[0]?.[2];
+      if (typeof payload !== "string") continue;
+      const inner = JSON.parse(payload);
+      const responseArray = inner?.[4]?.[0]?.[1];
+      if (!Array.isArray(responseArray)) continue;
+      const chunkText = responseArray.filter((c) => typeof c === "string").join("");
+      if (chunkText) textChunks.push(chunkText);
+    } catch {
+    }
+  }
+  return textChunks.join("");
+}
+function buildJsonResponse(text, model) {
+  const body = {
+    id: `chatcmpl-${randomUUID()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    choices: [
+      {
+        index: 0,
+        message: { role: "assistant", content: text },
+        finish_reason: "stop"
+      }
+    ],
+    usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+  };
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function buildStreamingResponse(text, model) {
+  const encoder = new TextEncoder();
+  const id = `chatcmpl-${randomUUID()}`;
+  const created = Math.floor(Date.now() / 1e3);
+  const chunk1 = `data: ${JSON.stringify({
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model,
+    choices: [{ index: 0, delta: { role: "assistant", content: "" }, finish_reason: null }]
+  })}
+
+`;
+  const chunk2 = `data: ${JSON.stringify({
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model,
+    choices: [{ index: 0, delta: { content: text }, finish_reason: null }]
+  })}
+
+`;
+  const chunk3 = `data: ${JSON.stringify({
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model,
+    choices: [{ index: 0, delta: {}, finish_reason: "stop" }]
+  })}
+
+`;
+  const done = "data: [DONE]\n\n";
+  const readable = new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode(chunk1));
+      controller.enqueue(encoder.encode(chunk2));
+      controller.enqueue(encoder.encode(chunk3));
+      controller.enqueue(encoder.encode(done));
+      controller.close();
+    }
+  });
+  return new Response(readable, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+function readCredentialString(value) {
+  if (typeof value !== "string") return "";
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  return trimmed;
+}
+function readProviderSpecificString(providerSpecificData, keys) {
+  if (!providerSpecificData || typeof providerSpecificData !== "object") return "";
+  const data = providerSpecificData;
+  for (const key of keys) {
+    const v = data[key];
+    if (typeof v === "string" && v.trim().length > 0) return v.trim();
+  }
+  return "";
+}
+function extractTextContent(content) {
+  if (typeof content === "string") return content.trim();
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (typeof part === "string") return part;
+      if (part && typeof part === "object" && "text" in part) {
+        const text = part.text;
+        return typeof text === "string" ? text : "";
+      }
+      return "";
+    }).join("").trim();
+  }
+  return "";
+}
+function extractCookieValue(cookie, name) {
+  const pairs = cookie.split(";");
+  for (const pair of pairs) {
+    const [k, ...rest] = pair.trim().split("=");
+    if (k === name) return rest.join("=");
+  }
+  return null;
+}
+function parseEntryUrl(entryUrl) {
+  const fallback = { baseOrigin: "https://business.gemini.google", pathPrefix: "/home" };
+  const trimmed = entryUrl.trim();
+  if (!trimmed) return fallback;
+  const normalized = /^[a-z]+:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  try {
+    const u = new URL(normalized);
+    if (!u.host) return fallback;
+    return {
+      baseOrigin: `${u.protocol}//${u.host}`,
+      pathPrefix: u.pathname.replace(/\/$/, "") || "/"
+    };
+  } catch {
+    return fallback;
+  }
+}
+function computeSapisidHash(sapisid, origin) {
+  const epoch = Math.floor(Date.now() / 1e3);
+  const hashInput = `${epoch} ${sapisid} ${origin}`;
+  const hash = createHash("sha1").update(hashInput).digest("hex");
+  return `SAPISIDHASH ${epoch}_${hash}`;
+}
+export {
+  GeminiBusinessExecutor,
+  parseStreamResponse
+};

package/open-sse/executors/gemini-cli.js

@@ -0,0 +1,89 @@
+import { BaseExecutor } from "./base.js";
+import { PROVIDERS } from "../config/providers.js";
+import { OAUTH_ENDPOINTS, GEMINI_CLI_API_CLIENT, geminiCLIUserAgent } from "../config/appConstants.js";
+
+export class GeminiCLIExecutor extends BaseExecutor {
+  constructor() {
+    super("gemini-cli", PROVIDERS["gemini-cli"]);
+  }
+
+  buildUrl(model, stream, urlIndex = 0) {
+    const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+    return `${this.config.baseUrl}:${action}`;
+  }
+
+  buildHeaders(credentials, stream = true) {
+    return {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${credentials.accessToken}`,
+      "User-Agent": geminiCLIUserAgent(this._currentModel),
+      "X-Goog-Api-Client": GEMINI_CLI_API_CLIENT,
+      "Accept": stream ? "text/event-stream" : "application/json"
+    };
+  }
+
+  transformRequest(model, body, stream, credentials) {
+    // Store model for use in buildHeaders (called by base.execute after transformRequest)
+    this._currentModel = model;
+    // Cloud Code Assist wraps the Gemini payload: { project, model, request: <body> }
+    if (body && body.request && body.model) return body;
+    return {
+      project: credentials?.projectId || body?.project,
+      model,
+      request: body
+    };
+  }
+
+  // Parse RetryInfo.retryDelay from Google API 429 body to surface upstream retry hint
+  parseError(response, bodyText) {
+    const base = super.parseError(response, bodyText);
+    if (response.status !== 429 || !bodyText) return base;
+    try {
+      const parsed = JSON.parse(bodyText);
+      const details = parsed?.error?.details;
+      if (Array.isArray(details)) {
+        for (const d of details) {
+          if (d?.["@type"] === "type.googleapis.com/google.rpc.RetryInfo" && d?.retryDelay) {
+            base.retryAfter = d.retryDelay;
+            break;
+          }
+        }
+      }
+    } catch {}
+    return base;
+  }
+
+  async refreshCredentials(credentials, log) {
+    if (!credentials.refreshToken) return null;
+
+    try {
+      const response = await fetch(OAUTH_ENDPOINTS.google.token, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json" },
+        body: new URLSearchParams({
+          grant_type: "refresh_token",
+          refresh_token: credentials.refreshToken,
+          client_id: this.config.clientId,
+          client_secret: this.config.clientSecret
+        })
+      });
+
+      if (!response.ok) return null;
+
+      const tokens = await response.json();
+      log?.info?.("TOKEN", "Gemini CLI refreshed");
+
+      return {
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token || credentials.refreshToken,
+        expiresIn: tokens.expires_in,
+        projectId: credentials.projectId
+      };
+    } catch (error) {
+      log?.error?.("TOKEN", `Gemini CLI refresh error: ${error.message}`);
+      return null;
+    }
+  }
+}
+
+export default GeminiCLIExecutor;

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

@@ -0,0 +1,297 @@
+import { BaseExecutor } from "./base.ts";
+import { sanitizeErrorMessage } from "../utils/error.js";
+const GEMINI_URL = "https://gemini.google.com/app";
+function isMissingBrowserExecutable(message) {
+  if (!message) return false;
+  return /executable doesn't exist|executablenotfound|playwright install|chromium.*download/i.test(
+    message
+  );
+}
+const GEMINI_USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36";
+function formatChatCompletion(content, model, finishReason = "stop") {
+  return {
+    id: `chatcmpl-${Date.now()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    choices: [{ index: 0, message: { role: "assistant", content }, finish_reason: finishReason }],
+    usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+  };
+}
+function formatStreamChunk(content, model, finishReason = null) {
+  return {
+    id: `chatcmpl-${Date.now()}`,
+    object: "chat.completion.chunk",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    choices: [{ index: 0, delta: content ? { content } : {}, finish_reason: finishReason }]
+  };
+}
+function parseCookies(raw) {
+  return raw.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
+    const eqIdx = part.indexOf("=");
+    if (eqIdx === -1) return null;
+    const name = part.substring(0, eqIdx).trim();
+    const value = part.substring(eqIdx + 1).trim();
+    if (!name || !value) return null;
+    const lowerName = name.toLowerCase();
+    if (["path", "domain", "expires", "max-age", "secure", "httponly", "samesite"].includes(
+      lowerName
+    )) {
+      return null;
+    }
+    return { name, value };
+  }).filter(Boolean);
+}
+function parseStreamResponse(raw) {
+  const lines = raw.split("\n");
+  const textChunks = [];
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line === ")]}'" || /^\d+$/.test(line)) continue;
+    if (!line.includes("wrb.fr")) continue;
+    try {
+      const arr = JSON.parse(line);
+      if (!Array.isArray(arr) || !Array.isArray(arr[0]) || arr[0][0] !== "wrb.fr") continue;
+      const payload = arr[0]?.[2];
+      if (typeof payload !== "string") continue;
+      const inner = JSON.parse(payload);
+      const responseArray = inner?.[4]?.[0]?.[1];
+      if (!Array.isArray(responseArray)) continue;
+      const text = responseArray.filter((c) => typeof c === "string").join("");
+      if (text) textChunks.push(text);
+    } catch {
+    }
+  }
+  return textChunks.join("");
+}
+function readCredentialString(value) {
+  if (typeof value !== "string") return "";
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : "";
+}
+function readProviderSpecificString(providerSpecificData, keys) {
+  if (!providerSpecificData || typeof providerSpecificData !== "object" || Array.isArray(providerSpecificData)) {
+    return "";
+  }
+  const data = providerSpecificData;
+  for (const key of keys) {
+    const value = readCredentialString(data[key]);
+    if (value) return value;
+  }
+  return "";
+}
+function normalizeGeminiCookieInput(raw, cookieName = "__Secure-1PSID") {
+  const trimmed = raw.trim();
+  if (!trimmed) return "";
+  return trimmed.includes("=") ? trimmed : `${cookieName}=${trimmed}`;
+}
+function resolveGeminiWebCookie(credentials) {
+  const directCookie = readCredentialString(credentials?.apiKey) || readCredentialString(credentials?.cookie);
+  if (directCookie) return normalizeGeminiCookieInput(directCookie);
+  const providerSpecificData = credentials?.providerSpecificData;
+  const cookie = readProviderSpecificString(providerSpecificData, ["cookie"]);
+  if (cookie) return normalizeGeminiCookieInput(cookie);
+  const psid = readProviderSpecificString(providerSpecificData, ["__Secure-1PSID"]);
+  const psidts = readProviderSpecificString(providerSpecificData, ["__Secure-1PSIDTS"]);
+  return [
+    psid ? normalizeGeminiCookieInput(psid, "__Secure-1PSID") : "",
+    psidts ? normalizeGeminiCookieInput(psidts, "__Secure-1PSIDTS") : ""
+  ].filter(Boolean).join("; ");
+}
+class GeminiWebExecutor extends BaseExecutor {
+  constructor() {
+    super("gemini-web", { id: "gemini-web", baseUrl: GEMINI_URL });
+  }
+  async execute(input) {
+    const { model, body, stream, credentials, signal } = input;
+    const requestBody = body;
+    const cookie = resolveGeminiWebCookie(credentials);
+    if (!cookie) {
+      return {
+        response: new Response(JSON.stringify({ error: "Missing Gemini cookies" }), {
+          status: 401,
+          headers: { "Content-Type": "application/json" }
+        }),
+        url: GEMINI_URL,
+        headers: {},
+        transformedBody: body
+      };
+    }
+    const messages = requestBody.messages || [];
+    const lastUserMsg = messages.filter((m) => m.role === "user").pop();
+    const prompt = lastUserMsg?.content || "";
+    if (!prompt) {
+      return {
+        response: new Response(JSON.stringify({ error: "No user message found" }), {
+          status: 400,
+          headers: { "Content-Type": "application/json" }
+        }),
+        url: GEMINI_URL,
+        headers: {},
+        transformedBody: body
+      };
+    }
+    let browser = null;
+    let abortBrowser = null;
+    try {
+      if (signal?.aborted) {
+        throw signal.reason instanceof Error ? signal.reason : new Error("Request aborted");
+      }
+      const { chromium } = await import("playwright");
+      browser = await chromium.launch({ headless: true });
+      abortBrowser = () => {
+        void browser?.close().catch(() => {
+        });
+      };
+      signal?.addEventListener("abort", abortBrowser, { once: true });
+      const context = await browser.newContext({ userAgent: GEMINI_USER_AGENT });
+      const cookiePairs = parseCookies(cookie);
+      await context.addCookies(
+        cookiePairs.map(({ name, value }) => ({
+          name,
+          value,
+          domain: ".google.com",
+          path: "/",
+          secure: true
+        }))
+      );
+      const page = await context.newPage();
+      let responseText = "";
+      let captured = false;
+      const responsePromise = new Promise((resolve) => {
+        page.on("response", async (resp) => {
+          if (captured || !resp.url().includes("StreamGenerate")) return;
+          captured = true;
+          try {
+            const raw = await resp.text();
+            responseText = parseStreamResponse(raw);
+          } catch {
+          }
+          resolve();
+        });
+      });
+      await page.goto(GEMINI_URL, { waitUntil: "domcontentloaded", timeout: 2e4 });
+      if (signal?.aborted) {
+        throw signal.reason instanceof Error ? signal.reason : new Error("Request aborted");
+      }
+      await page.waitForTimeout(3e3);
+      const inputEl = await page.waitForSelector(".ql-editor, [contenteditable='true']", {
+        timeout: 1e4
+      });
+      await inputEl.click();
+      await page.keyboard.type(prompt, { delay: 10 });
+      await page.waitForTimeout(300);
+      await page.keyboard.press("Enter");
+      await Promise.race([responsePromise, page.waitForTimeout(3e4)]);
+      if (signal?.aborted) {
+        throw signal.reason instanceof Error ? signal.reason : new Error("Request aborted");
+      }
+      if (!responseText) {
+        return {
+          response: new Response(JSON.stringify({ error: "No response from Gemini" }), {
+            status: 502,
+            headers: { "Content-Type": "application/json" }
+          }),
+          url: GEMINI_URL,
+          headers: {},
+          transformedBody: body
+        };
+      }
+      const modelId = model || "gemini-2.5-pro";
+      if (stream) {
+        const encoder = new TextEncoder();
+        const readable = new ReadableStream(
+          {
+            start(controller) {
+              controller.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify(formatStreamChunk(responseText, modelId))}
+
+`
+                )
+              );
+              controller.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify(formatStreamChunk("", modelId, "stop"))}
+
+`
+                )
+              );
+              controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+              controller.close();
+            }
+          },
+          { highWaterMark: 16384 }
+        );
+        return {
+          response: new Response(readable, {
+            status: 200,
+            headers: {
+              "Content-Type": "text/event-stream",
+              "Cache-Control": "no-cache",
+              Connection: "keep-alive"
+            }
+          }),
+          url: GEMINI_URL,
+          headers: {},
+          transformedBody: body
+        };
+      }
+      return {
+        response: new Response(JSON.stringify(formatChatCompletion(responseText, modelId)), {
+          status: 200,
+          headers: { "Content-Type": "application/json" }
+        }),
+        url: GEMINI_URL,
+        headers: {},
+        transformedBody: body
+      };
+    } catch (error) {
+      const rawMessage = error instanceof Error ? error.message : "Unknown error";
+      if (isMissingBrowserExecutable(rawMessage)) {
+        return {
+          response: new Response(
+            JSON.stringify({
+              error: "Gemini Web requires the Playwright Chromium browser, which is not installed. Run `npx playwright install chromium` on the host (or rebuild the Docker image with browsers)."
+            }),
+            {
+              status: 503,
+              headers: {
+                "Content-Type": "application/json",
+                "X-Omni-Fallback-Hint": "connection_cooldown"
+              }
+            }
+          ),
+          url: GEMINI_URL,
+          headers: {},
+          transformedBody: body
+        };
+      }
+      return {
+        response: new Response(
+          JSON.stringify({
+            error: sanitizeErrorMessage(rawMessage)
+          }),
+          { status: 500, headers: { "Content-Type": "application/json" } }
+        ),
+        url: GEMINI_URL,
+        headers: {},
+        transformedBody: body
+      };
+    } finally {
+      if (abortBrowser) signal?.removeEventListener("abort", abortBrowser);
+      if (browser) {
+        try {
+          await browser.close();
+        } catch {
+        }
+      }
+    }
+  }
+}
+export {
+  GeminiWebExecutor,
+  isMissingBrowserExecutable,
+  parseStreamResponse
+};