@elvatis_com/openclaw-cli-bridge-elvatis 0.2.28 → 0.2.30

package/src/claude-browser.ts

@@ -0,0 +1,233 @@
+/**
+ * claude-browser.ts
+ *
+ * Claude.ai browser automation via Playwright DOM-polling.
+ * Identical strategy to grok-client.ts — no direct API calls,
+ * everything runs through the authenticated browser page.
+ *
+ * DOM structure (as of 2026-03-11):
+ *   Editor:   .ProseMirror (tiptap)
+ *   Messages: [data-test-render-count] divs, alternating user/assistant
+ *             Assistant messages: child div with class "group" (no "mb-1 mt-6")
+ */
+
+import type { BrowserContext, Page } from "playwright";
+
+export interface ChatMessage {
+  role: "system" | "user" | "assistant";
+  content: string;
+}
+
+export interface ClaudeBrowserOptions {
+  messages: ChatMessage[];
+  model?: string;
+  timeoutMs?: number;
+}
+
+export interface ClaudeBrowserResult {
+  content: string;
+  model: string;
+  finishReason: string;
+}
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const STABLE_CHECKS = 3;
+const STABLE_INTERVAL_MS = 500;
+const CLAUDE_HOME = "https://claude.ai/new";
+
+const MODEL_MAP: Record<string, string> = {
+  "claude-sonnet":       "claude-sonnet",
+  "claude-opus":         "claude-opus",
+  "claude-haiku":        "claude-haiku",
+  "claude-sonnet-4-5":   "claude-sonnet-4-5",
+  "claude-sonnet-4-6":   "claude-sonnet-4-6",
+  "claude-opus-4-5":     "claude-opus-4-5",
+};
+
+function resolveModel(m?: string): string {
+  const clean = (m ?? "claude-sonnet").replace("web-claude/", "");
+  return MODEL_MAP[clean] ?? "claude-sonnet";
+}
+
+function flattenMessages(messages: ChatMessage[]): string {
+  if (messages.length === 1) return messages[0].content;
+  return messages
+    .map((m) => {
+      if (m.role === "system") return `[System]: ${m.content}`;
+      if (m.role === "assistant") return `[Assistant]: ${m.content}`;
+      return m.content;
+    })
+    .join("\n\n");
+}
+
+/**
+ * Get or create a claude.ai/new page in the given context.
+ */
+export async function getOrCreateClaudePage(
+  context: BrowserContext
+): Promise<{ page: Page; owned: boolean }> {
+  const existing = context.pages().filter((p) => p.url().startsWith("https://claude.ai"));
+  if (existing.length > 0) return { page: existing[0], owned: false };
+  const page = await context.newPage();
+  await page.goto(CLAUDE_HOME, { waitUntil: "domcontentloaded", timeout: 15_000 });
+  await new Promise((r) => setTimeout(r, 2_000));
+  return { page, owned: true };
+}
+
+/**
+ * Count assistant message containers currently on the page.
+ * Assistant messages: [data-test-render-count] where child div lacks "mb-1 mt-6".
+ */
+async function countAssistantMessages(page: Page): Promise<number> {
+  return page.evaluate(() => {
+    const all = [...document.querySelectorAll("[data-test-render-count]")];
+    return all.filter((el) => {
+      const child = el.querySelector("div");
+      return child && !child.className.includes("mb-1");
+    }).length;
+  });
+}
+
+/**
+ * Get the text of the last assistant message.
+ */
+async function getLastAssistantText(page: Page): Promise<string> {
+  return page.evaluate(() => {
+    const all = [...document.querySelectorAll("[data-test-render-count]")];
+    const assistants = all.filter((el) => {
+      const child = el.querySelector("div");
+      return child && !child.className.includes("mb-1");
+    });
+    return assistants[assistants.length - 1]?.textContent?.trim() ?? "";
+  });
+}
+
+/**
+ * Send a message and wait for a stable response via DOM-polling.
+ */
+async function sendAndWait(
+  page: Page,
+  message: string,
+  timeoutMs: number,
+  log: (msg: string) => void
+): Promise<string> {
+  const countBefore = await countAssistantMessages(page);
+
+  // Type into ProseMirror editor
+  await page.evaluate((msg: string) => {
+    const ed = document.querySelector(".ProseMirror") as HTMLElement | null;
+    if (!ed) throw new Error("Claude editor not found");
+    ed.focus();
+    document.execCommand("insertText", false, msg);
+  }, message);
+
+  await new Promise((r) => setTimeout(r, 300));
+  await page.keyboard.press("Enter");
+
+  log(`claude-browser: message sent (${message.length} chars), waiting…`);
+
+  const deadline = Date.now() + timeoutMs;
+  let lastText = "";
+  let stableCount = 0;
+
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, STABLE_INTERVAL_MS));
+
+    const currentCount = await countAssistantMessages(page);
+    if (currentCount <= countBefore) continue; // response not started yet
+
+    const text = await getLastAssistantText(page);
+
+    if (text && text === lastText) {
+      stableCount++;
+      if (stableCount >= STABLE_CHECKS) {
+        log(`claude-browser: response stable (${text.length} chars)`);
+        return text;
+      }
+    } else {
+      stableCount = 0;
+      lastText = text;
+    }
+  }
+
+  throw new Error(`claude.ai response timeout after ${timeoutMs}ms`);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+export async function claudeComplete(
+  context: BrowserContext,
+  opts: ClaudeBrowserOptions,
+  log: (msg: string) => void
+): Promise<ClaudeBrowserResult> {
+  const { page, owned } = await getOrCreateClaudePage(context);
+  const model = resolveModel(opts.model);
+  const prompt = flattenMessages(opts.messages);
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+
+  log(`claude-browser: complete model=${model}`);
+
+  try {
+    const content = await sendAndWait(page, prompt, timeoutMs, log);
+    return { content, model, finishReason: "stop" };
+  } finally {
+    if (owned) await page.close().catch(() => {});
+  }
+}
+
+export async function claudeCompleteStream(
+  context: BrowserContext,
+  opts: ClaudeBrowserOptions,
+  onToken: (token: string) => void,
+  log: (msg: string) => void
+): Promise<ClaudeBrowserResult> {
+  const { page, owned } = await getOrCreateClaudePage(context);
+  const model = resolveModel(opts.model);
+  const prompt = flattenMessages(opts.messages);
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+
+  log(`claude-browser: stream model=${model}`);
+
+  const countBefore = await countAssistantMessages(page);
+
+  await page.evaluate((msg: string) => {
+    const ed = document.querySelector(".ProseMirror") as HTMLElement | null;
+    if (!ed) throw new Error("Claude editor not found");
+    ed.focus();
+    document.execCommand("insertText", false, msg);
+  }, prompt);
+  await new Promise((r) => setTimeout(r, 300));
+  await page.keyboard.press("Enter");
+
+  const deadline = Date.now() + timeoutMs;
+  let emittedLength = 0;
+  let lastText = "";
+  let stableCount = 0;
+
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, STABLE_INTERVAL_MS));
+
+    const currentCount = await countAssistantMessages(page);
+    if (currentCount <= countBefore) continue;
+
+    const text = await getLastAssistantText(page);
+
+    if (text.length > emittedLength) {
+      onToken(text.slice(emittedLength));
+      emittedLength = text.length;
+    }
+
+    if (text && text === lastText) {
+      stableCount++;
+      if (stableCount >= STABLE_CHECKS) {
+        log(`claude-browser: stream done (${text.length} chars)`);
+        return { content: text, model, finishReason: "stop" };
+      }
+    } else {
+      stableCount = 0;
+      lastText = text;
+    }
+  }
+
+  throw new Error(`claude.ai stream timeout after ${timeoutMs}ms`);
+}

package/src/gemini-browser.ts

@@ -0,0 +1,242 @@
+/**
+ * gemini-browser.ts
+ *
+ * Gemini web automation via Playwright DOM-polling.
+ * Strategy identical to grok-client.ts / claude-browser.ts.
+ *
+ * DOM structure (confirmed 2026-03-11):
+ *   Editor:   .ql-editor (Quill — use page.type(), NOT execCommand)
+ *   Response: message-content (custom element, innerText = clean response)
+ *   Also:     .markdown (same content, markdown-rendered)
+ */
+
+import type { BrowserContext, Page } from "playwright";
+
+export interface ChatMessage {
+  role: "system" | "user" | "assistant";
+  content: string;
+}
+
+export interface GeminiBrowserOptions {
+  messages: ChatMessage[];
+  model?: string;
+  timeoutMs?: number;
+}
+
+export interface GeminiBrowserResult {
+  content: string;
+  model: string;
+  finishReason: string;
+}
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const STABLE_CHECKS = 3;
+const STABLE_INTERVAL_MS = 600; // slightly longer — Gemini streams slower
+const GEMINI_HOME = "https://gemini.google.com/app";
+
+const MODEL_MAP: Record<string, string> = {
+  "gemini-2-5-pro":        "gemini-2.5-pro",
+  "gemini-2-5-flash":      "gemini-2.5-flash",
+  "gemini-flash":          "gemini-flash",
+  "gemini-pro":            "gemini-pro",
+  "gemini-3-pro":          "gemini-3-pro",
+  "gemini-3-flash":        "gemini-3-flash",
+};
+
+function resolveModel(m?: string): string {
+  const clean = (m ?? "gemini-2-5-pro").replace("web-gemini/", "").replace(/\./g, "-");
+  return MODEL_MAP[clean] ?? "gemini-2.5-pro";
+}
+
+function flattenMessages(messages: ChatMessage[]): string {
+  if (messages.length === 1) return messages[0].content;
+  return messages
+    .map((m) => {
+      if (m.role === "system") return `[System]: ${m.content}`;
+      if (m.role === "assistant") return `[Assistant]: ${m.content}`;
+      return m.content;
+    })
+    .join("\n\n");
+}
+
+/**
+ * Get or create a Gemini page in the given context.
+ */
+export async function getOrCreateGeminiPage(
+  context: BrowserContext
+): Promise<{ page: Page; owned: boolean }> {
+  const existing = context.pages().filter((p) => p.url().startsWith("https://gemini.google.com"));
+  if (existing.length > 0) return { page: existing[0], owned: false };
+  const page = await context.newPage();
+  await page.goto(GEMINI_HOME, { waitUntil: "domcontentloaded", timeout: 15_000 });
+  await new Promise((r) => setTimeout(r, 2_000));
+  return { page, owned: true };
+}
+
+/**
+ * Count model-response elements on the page (= number of assistant turns).
+ */
+async function countResponses(page: Page): Promise<number> {
+  return page.evaluate(() => document.querySelectorAll("model-response").length);
+}
+
+/**
+ * Get the text of the last model-response via message-content element.
+ * Uses message-content (cleanest, no "Gemini hat gesagt" prefix).
+ */
+async function getLastResponseText(page: Page): Promise<string> {
+  return page.evaluate(() => {
+    const els = [...document.querySelectorAll("message-content")];
+    if (!els.length) return "";
+    return els[els.length - 1].textContent?.trim() ?? "";
+  });
+}
+
+/**
+ * Check if Gemini is still generating (streaming indicator present).
+ */
+async function isStreaming(page: Page): Promise<boolean> {
+  return page.evaluate(() => {
+    // Gemini shows a stop button while streaming
+    const stopBtn = document.querySelector('button[aria-label*="stop"], button[aria-label*="Stop"], button[aria-label*="stopp"]');
+    return !!stopBtn;
+  });
+}
+
+/**
+ * Send a message and wait for a stable response via DOM-polling.
+ */
+async function sendAndWait(
+  page: Page,
+  message: string,
+  timeoutMs: number,
+  log: (msg: string) => void
+): Promise<string> {
+  const countBefore = await countResponses(page);
+
+  // Quill editor: use page.type() (not execCommand — Quill ignores it)
+  const editor = page.locator(".ql-editor");
+  await editor.click();
+  await editor.type(message, { delay: 10 });
+  await new Promise((r) => setTimeout(r, 300));
+  await page.keyboard.press("Enter");
+
+  log(`gemini-browser: message sent (${message.length} chars), waiting…`);
+
+  const deadline = Date.now() + timeoutMs;
+  let lastText = "";
+  let stableCount = 0;
+
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, STABLE_INTERVAL_MS));
+
+    // Wait for new response to appear
+    const currentCount = await countResponses(page);
+    if (currentCount <= countBefore) continue;
+
+    // Still streaming? Don't start stable-check yet
+    const streaming = await isStreaming(page);
+    if (streaming) {
+      stableCount = 0;
+      lastText = await getLastResponseText(page);
+      continue;
+    }
+
+    const text = await getLastResponseText(page);
+    if (!text) continue;
+
+    if (text === lastText) {
+      stableCount++;
+      if (stableCount >= STABLE_CHECKS) {
+        log(`gemini-browser: response stable (${text.length} chars)`);
+        return text;
+      }
+    } else {
+      stableCount = 0;
+      lastText = text;
+    }
+  }
+
+  throw new Error(`gemini.google.com response timeout after ${timeoutMs}ms`);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+export async function geminiComplete(
+  context: BrowserContext,
+  opts: GeminiBrowserOptions,
+  log: (msg: string) => void
+): Promise<GeminiBrowserResult> {
+  const { page, owned } = await getOrCreateGeminiPage(context);
+  const model = resolveModel(opts.model);
+  const prompt = flattenMessages(opts.messages);
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+
+  log(`gemini-browser: complete model=${model}`);
+
+  try {
+    const content = await sendAndWait(page, prompt, timeoutMs, log);
+    return { content, model, finishReason: "stop" };
+  } finally {
+    if (owned) await page.close().catch(() => {});
+  }
+}
+
+export async function geminiCompleteStream(
+  context: BrowserContext,
+  opts: GeminiBrowserOptions,
+  onToken: (token: string) => void,
+  log: (msg: string) => void
+): Promise<GeminiBrowserResult> {
+  const { page, owned } = await getOrCreateGeminiPage(context);
+  const model = resolveModel(opts.model);
+  const prompt = flattenMessages(opts.messages);
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+
+  log(`gemini-browser: stream model=${model}`);
+
+  const countBefore = await countResponses(page);
+
+  const editor = page.locator(".ql-editor");
+  await editor.click();
+  await editor.type(prompt, { delay: 10 });
+  await new Promise((r) => setTimeout(r, 300));
+  await page.keyboard.press("Enter");
+
+  const deadline = Date.now() + timeoutMs;
+  let emittedLength = 0;
+  let lastText = "";
+  let stableCount = 0;
+
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, STABLE_INTERVAL_MS));
+
+    const currentCount = await countResponses(page);
+    if (currentCount <= countBefore) continue;
+
+    const text = await getLastResponseText(page);
+
+    if (text.length > emittedLength) {
+      onToken(text.slice(emittedLength));
+      emittedLength = text.length;
+    }
+
+    const streaming = await isStreaming(page);
+    if (streaming) { stableCount = 0; continue; }
+
+    if (text && text === lastText) {
+      stableCount++;
+      if (stableCount >= STABLE_CHECKS) {
+        log(`gemini-browser: stream done (${text.length} chars)`);
+        if (owned) await page.close().catch(() => {});
+        return { content: text, model, finishReason: "stop" };
+      }
+    } else {
+      stableCount = 0;
+      lastText = text;
+    }
+  }
+
+  if (owned) await page.close().catch(() => {});
+  throw new Error(`gemini.google.com stream timeout after ${timeoutMs}ms`);
+}

package/src/proxy-server.ts

@@ -13,6 +13,8 @@ import { randomBytes } from "node:crypto";
 import { type ChatMessage, routeToCliRunner } from "./cli-runner.js";
 import { scheduleTokenRefresh, setAuthLogger, stopTokenRefresh } from "./claude-auth.js";
 import { grokComplete, grokCompleteStream, type ChatMessage as GrokChatMessage } from "./grok-client.js";
+import { claudeComplete, claudeCompleteStream, type ChatMessage as ClaudeBrowserChatMessage } from "./claude-browser.js";
+import { geminiComplete, geminiCompleteStream, type ChatMessage as GeminiBrowserChatMessage } from "./gemini-browser.js";
 import type { BrowserContext } from "playwright";
 
 export type GrokCompleteOptions = Parameters<typeof grokComplete>[1];
@@ -33,6 +35,22 @@ export interface ProxyServerOptions {
   _grokComplete?: typeof grokComplete;
   /** Override for testing — replaces grokCompleteStream */
   _grokCompleteStream?: typeof grokCompleteStream;
+  /** Returns the current authenticated Claude BrowserContext (null if not logged in) */
+  getClaudeContext?: () => BrowserContext | null;
+  /** Async lazy connect — called when getClaudeContext returns null */
+  connectClaudeContext?: () => Promise<BrowserContext | null>;
+  /** Override for testing — replaces claudeComplete */
+  _claudeComplete?: typeof claudeComplete;
+  /** Override for testing — replaces claudeCompleteStream */
+  _claudeCompleteStream?: typeof claudeCompleteStream;
+  /** Returns the current authenticated Gemini BrowserContext (null if not logged in) */
+  getGeminiContext?: () => BrowserContext | null;
+  /** Async lazy connect — called when getGeminiContext returns null */
+  connectGeminiContext?: () => Promise<BrowserContext | null>;
+  /** Override for testing — replaces geminiComplete */
+  _geminiComplete?: typeof geminiComplete;
+  /** Override for testing — replaces geminiCompleteStream */
+  _geminiCompleteStream?: typeof geminiCompleteStream;
 }
 
 /** Available CLI bridge models for GET /v1/models */
@@ -78,6 +96,15 @@ export const CLI_MODELS = [
   { id: "web-grok/grok-3-fast",      name: "Grok 3 Fast (web session)",      contextWindow: 131_072, maxTokens: 131_072 },
   { id: "web-grok/grok-3-mini",      name: "Grok 3 Mini (web session)",      contextWindow: 131_072, maxTokens: 131_072 },
   { id: "web-grok/grok-3-mini-fast", name: "Grok 3 Mini Fast (web session)", contextWindow: 131_072, maxTokens: 131_072 },
+  // Claude web-session models (requires /claude-login)
+  { id: "web-claude/claude-sonnet",   name: "Claude Sonnet (web session)",   contextWindow: 200_000, maxTokens: 8192 },
+  { id: "web-claude/claude-opus",     name: "Claude Opus (web session)",     contextWindow: 200_000, maxTokens: 8192 },
+  { id: "web-claude/claude-haiku",    name: "Claude Haiku (web session)",    contextWindow: 200_000, maxTokens: 8192 },
+  // Gemini web-session models (requires /gemini-login)
+  { id: "web-gemini/gemini-2-5-pro",   name: "Gemini 2.5 Pro (web session)",   contextWindow: 1_000_000, maxTokens: 8192 },
+  { id: "web-gemini/gemini-2-5-flash", name: "Gemini 2.5 Flash (web session)", contextWindow: 1_000_000, maxTokens: 8192 },
+  { id: "web-gemini/gemini-3-pro",     name: "Gemini 3 Pro (web session)",     contextWindow: 1_000_000, maxTokens: 8192 },
+  { id: "web-gemini/gemini-3-flash",   name: "Gemini 3 Flash (web session)",   contextWindow: 1_000_000, maxTokens: 8192 },
 ];
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -249,6 +276,104 @@ async function handleRequest(
     }
     // ─────────────────────────────────────────────────────────────────────────
 
+    // ── Claude web-session routing ────────────────────────────────────────────
+    if (model.startsWith("web-claude/")) {
+      let claudeCtx = opts.getClaudeContext?.() ?? null;
+      if (!claudeCtx && opts.connectClaudeContext) {
+        claudeCtx = await opts.connectClaudeContext();
+      }
+      if (!claudeCtx) {
+        res.writeHead(503, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: { message: "No active claude.ai session. Use /claude-login to authenticate.", code: "no_claude_session" } }));
+        return;
+      }
+      const timeoutMs = opts.timeoutMs ?? 120_000;
+      const claudeMessages = messages as ClaudeBrowserChatMessage[];
+      const doClaudeComplete = opts._claudeComplete ?? claudeComplete;
+      const doClaudeCompleteStream = opts._claudeCompleteStream ?? claudeCompleteStream;
+      try {
+        if (stream) {
+          res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive", ...corsHeaders() });
+          sendSseChunk(res, { id, created, model, delta: { role: "assistant" }, finish_reason: null });
+          const result = await doClaudeCompleteStream(
+            claudeCtx,
+            { messages: claudeMessages, model, timeoutMs },
+            (token) => sendSseChunk(res, { id, created, model, delta: { content: token }, finish_reason: null }),
+            opts.log
+          );
+          sendSseChunk(res, { id, created, model, delta: {}, finish_reason: result.finishReason });
+          res.write("data: [DONE]\n\n");
+          res.end();
+        } else {
+          const result = await doClaudeComplete(claudeCtx, { messages: claudeMessages, model, timeoutMs }, opts.log);
+          res.writeHead(200, { "Content-Type": "application/json", ...corsHeaders() });
+          res.end(JSON.stringify({
+            id, object: "chat.completion", created, model,
+            choices: [{ index: 0, message: { role: "assistant", content: result.content }, finish_reason: result.finishReason }],
+            usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+          }));
+        }
+      } catch (err) {
+        const msg = (err as Error).message;
+        opts.warn(`[cli-bridge] Claude browser error for ${model}: ${msg}`);
+        if (!res.headersSent) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: { message: msg, type: "claude_browser_error" } }));
+        }
+      }
+      return;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+
+    // ── Gemini web-session routing ────────────────────────────────────────────
+    if (model.startsWith("web-gemini/")) {
+      let geminiCtx = opts.getGeminiContext?.() ?? null;
+      if (!geminiCtx && opts.connectGeminiContext) {
+        geminiCtx = await opts.connectGeminiContext();
+      }
+      if (!geminiCtx) {
+        res.writeHead(503, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: { message: "No active gemini.google.com session. Use /gemini-login to authenticate.", code: "no_gemini_session" } }));
+        return;
+      }
+      const timeoutMs = opts.timeoutMs ?? 120_000;
+      const geminiMessages = messages as GeminiBrowserChatMessage[];
+      const doGeminiComplete = opts._geminiComplete ?? geminiComplete;
+      const doGeminiCompleteStream = opts._geminiCompleteStream ?? geminiCompleteStream;
+      try {
+        if (stream) {
+          res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive", ...corsHeaders() });
+          sendSseChunk(res, { id, created, model, delta: { role: "assistant" }, finish_reason: null });
+          const result = await doGeminiCompleteStream(
+            geminiCtx,
+            { messages: geminiMessages, model, timeoutMs },
+            (token) => sendSseChunk(res, { id, created, model, delta: { content: token }, finish_reason: null }),
+            opts.log
+          );
+          sendSseChunk(res, { id, created, model, delta: {}, finish_reason: result.finishReason });
+          res.write("data: [DONE]\n\n");
+          res.end();
+        } else {
+          const result = await doGeminiComplete(geminiCtx, { messages: geminiMessages, model, timeoutMs }, opts.log);
+          res.writeHead(200, { "Content-Type": "application/json", ...corsHeaders() });
+          res.end(JSON.stringify({
+            id, object: "chat.completion", created, model,
+            choices: [{ index: 0, message: { role: "assistant", content: result.content }, finish_reason: result.finishReason }],
+            usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+          }));
+        }
+      } catch (err) {
+        const msg = (err as Error).message;
+        opts.warn(`[cli-bridge] Gemini browser error for ${model}: ${msg}`);
+        if (!res.headersSent) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: { message: msg, type: "gemini_browser_error" } }));
+        }
+      }
+      return;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+
     // ── CLI runner routing (Gemini / Claude Code) ─────────────────────────────
     let content: string;
     try {