@elvatis_com/openclaw-cli-bridge-elvatis 0.2.29 → 1.0.0

package/src/chatgpt-browser.ts

@@ -0,0 +1,253 @@
+/**
+ * chatgpt-browser.ts
+ *
+ * ChatGPT web automation via Playwright DOM-polling.
+ * Strategy identical to claude-browser.ts / grok-client.ts.
+ *
+ * DOM structure (confirmed 2026-03-11):
+ *   Editor:   #prompt-textarea (ProseMirror — use execCommand)
+ *   Send btn: button[data-testid="send-button"]
+ *   Response: [data-message-author-role="assistant"] (last element)
+ *   Streaming indicator: button[data-testid="stop-button"]
+ */
+
+import type { BrowserContext, Page } from "playwright";
+
+export interface ChatMessage {
+  role: "system" | "user" | "assistant";
+  content: string;
+}
+
+export interface ChatGPTBrowserOptions {
+  messages: ChatMessage[];
+  model?: string;
+  timeoutMs?: number;
+}
+
+export interface ChatGPTBrowserResult {
+  content: string;
+  model: string;
+  finishReason: string;
+}
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const STABLE_CHECKS = 3;
+const STABLE_INTERVAL_MS = 500;
+const CHATGPT_HOME = "https://chatgpt.com";
+
+const MODEL_MAP: Record<string, string> = {
+  "gpt-4o":        "gpt-4o",
+  "gpt-4o-mini":   "gpt-4o-mini",
+  "gpt-o3":        "o3",
+  "gpt-o4-mini":   "o4-mini",
+  "gpt-4-1":       "gpt-4.1",
+  "gpt-5":         "gpt-5",
+};
+
+function resolveModel(m?: string): string {
+  const clean = (m ?? "gpt-4o").replace("web-chatgpt/", "");
+  return MODEL_MAP[clean] ?? clean;
+}
+
+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 chatgpt.com page in the given context.
+ */
+export async function getOrCreateChatGPTPage(
+  context: BrowserContext
+): Promise<{ page: Page; owned: boolean }> {
+  const existing = context.pages().filter((p) => p.url().startsWith("https://chatgpt.com"));
+  if (existing.length > 0) return { page: existing[0], owned: false };
+  const page = await context.newPage();
+  await page.goto(CHATGPT_HOME, { waitUntil: "domcontentloaded", timeout: 15_000 });
+  await new Promise((r) => setTimeout(r, 2_000));
+  return { page, owned: true };
+}
+
+/**
+ * Count assistant messages on the page.
+ */
+async function countAssistantMessages(page: Page): Promise<number> {
+  return page.evaluate(() =>
+    document.querySelectorAll('[data-message-author-role="assistant"]').length
+  );
+}
+
+/**
+ * Get the text of the last assistant message.
+ */
+async function getLastAssistantText(page: Page): Promise<string> {
+  return page.evaluate(() => {
+    const els = [...document.querySelectorAll('[data-message-author-role="assistant"]')];
+    return els[els.length - 1]?.textContent?.trim() ?? "";
+  });
+}
+
+/**
+ * Check if ChatGPT is still generating (stop button visible).
+ */
+async function isStreaming(page: Page): Promise<boolean> {
+  return page.evaluate(() =>
+    !!document.querySelector('button[data-testid="stop-button"]')
+  );
+}
+
+/**
+ * Send a message and wait for stable response.
+ */
+async function sendAndWait(
+  page: Page,
+  message: string,
+  timeoutMs: number,
+  log: (msg: string) => void
+): Promise<string> {
+  const countBefore = await countAssistantMessages(page);
+
+  // Type into ProseMirror via execCommand
+  await page.evaluate((msg: string) => {
+    const ed = document.querySelector("#prompt-textarea") as HTMLElement | null;
+    if (!ed) throw new Error("ChatGPT editor (#prompt-textarea) not found");
+    ed.focus();
+    document.execCommand("insertText", false, msg);
+  }, message);
+
+  await new Promise((r) => setTimeout(r, 300));
+
+  // Click send button (preferred) or Enter
+  const sendBtn = page.locator('button[data-testid="send-button"]').first();
+  const hasSendBtn = await sendBtn.isVisible().catch(() => false);
+  if (hasSendBtn) {
+    await sendBtn.click();
+  } else {
+    await page.keyboard.press("Enter");
+  }
+
+  log(`chatgpt-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;
+
+    // Still generating?
+    const streaming = await isStreaming(page);
+    if (streaming) { stableCount = 0; continue; }
+
+    const text = await getLastAssistantText(page);
+    if (!text) continue;
+
+    if (text === lastText) {
+      stableCount++;
+      if (stableCount >= STABLE_CHECKS) {
+        log(`chatgpt-browser: response stable (${text.length} chars)`);
+        return text;
+      }
+    } else {
+      stableCount = 0;
+      lastText = text;
+    }
+  }
+
+  throw new Error(`chatgpt.com response timeout after ${timeoutMs}ms`);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+export async function chatgptComplete(
+  context: BrowserContext,
+  opts: ChatGPTBrowserOptions,
+  log: (msg: string) => void
+): Promise<ChatGPTBrowserResult> {
+  const { page, owned } = await getOrCreateChatGPTPage(context);
+  const model = resolveModel(opts.model);
+  const prompt = flattenMessages(opts.messages);
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+
+  log(`chatgpt-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 chatgptCompleteStream(
+  context: BrowserContext,
+  opts: ChatGPTBrowserOptions,
+  onToken: (token: string) => void,
+  log: (msg: string) => void
+): Promise<ChatGPTBrowserResult> {
+  const { page, owned } = await getOrCreateChatGPTPage(context);
+  const model = resolveModel(opts.model);
+  const prompt = flattenMessages(opts.messages);
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+
+  log(`chatgpt-browser: stream model=${model}`);
+
+  const countBefore = await countAssistantMessages(page);
+
+  await page.evaluate((msg: string) => {
+    const ed = document.querySelector("#prompt-textarea") as HTMLElement | null;
+    if (!ed) throw new Error("ChatGPT editor not found");
+    ed.focus();
+    document.execCommand("insertText", false, msg);
+  }, prompt);
+  await new Promise((r) => setTimeout(r, 300));
+  const sendBtn = page.locator('button[data-testid="send-button"]').first();
+  if (await sendBtn.isVisible().catch(() => false)) await sendBtn.click();
+  else 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;
+    }
+
+    const streaming = await isStreaming(page);
+    if (streaming) { stableCount = 0; continue; }
+
+    if (text && text === lastText) {
+      stableCount++;
+      if (stableCount >= STABLE_CHECKS) {
+        log(`chatgpt-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(`chatgpt.com 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

@@ -14,6 +14,8 @@ 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 { chatgptComplete, chatgptCompleteStream, type ChatMessage as ChatGPTBrowserChatMessage } from "./chatgpt-browser.js";
 import type { BrowserContext } from "playwright";
 
 export type GrokCompleteOptions = Parameters<typeof grokComplete>[1];
@@ -42,6 +44,22 @@ export interface ProxyServerOptions {
   _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;
+  /** Returns the current authenticated ChatGPT BrowserContext */
+  getChatGPTContext?: () => BrowserContext | null;
+  /** Async lazy connect for ChatGPT */
+  connectChatGPTContext?: () => Promise<BrowserContext | null>;
+  /** Override for testing */
+  _chatgptComplete?: typeof chatgptComplete;
+  /** Override for testing */
+  _chatgptCompleteStream?: typeof chatgptCompleteStream;
 }
 
 /** Available CLI bridge models for GET /v1/models */
@@ -91,6 +109,17 @@ export const CLI_MODELS = [
   { 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 },
+  // ChatGPT web-session models (requires /chatgpt-login)
+  { id: "web-chatgpt/gpt-4o",       name: "GPT-4o (web session)",       contextWindow: 128_000, maxTokens: 16_384 },
+  { id: "web-chatgpt/gpt-4o-mini",  name: "GPT-4o Mini (web session)",  contextWindow: 128_000, maxTokens: 16_384 },
+  { id: "web-chatgpt/gpt-o3",       name: "o3 (web session)",           contextWindow: 200_000, maxTokens: 100_000 },
+  { id: "web-chatgpt/gpt-o4-mini",  name: "o4-mini (web session)",      contextWindow: 200_000, maxTokens: 100_000 },
+  { id: "web-chatgpt/gpt-5",        name: "GPT-5 (web session)",        contextWindow: 1_000_000, maxTokens: 32_768 },
 ];
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -311,6 +340,92 @@ async function handleRequest(
     }
     // ─────────────────────────────────────────────────────────────────────────
 
+    // ── 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;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+
+    // ── ChatGPT web-session routing ───────────────────────────────────────────
+    if (model.startsWith("web-chatgpt/")) {
+      let chatgptCtx = opts.getChatGPTContext?.() ?? null;
+      if (!chatgptCtx && opts.connectChatGPTContext) chatgptCtx = await opts.connectChatGPTContext();
+      if (!chatgptCtx) {
+        res.writeHead(503, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: { message: "No active chatgpt.com session. Use /chatgpt-login to authenticate.", code: "no_chatgpt_session" } }));
+        return;
+      }
+      const timeoutMs = opts.timeoutMs ?? 120_000;
+      const msgs = messages as ChatGPTBrowserChatMessage[];
+      const doComplete = opts._chatgptComplete ?? chatgptComplete;
+      const doStream = opts._chatgptCompleteStream ?? chatgptCompleteStream;
+      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 doStream(chatgptCtx, { messages: msgs, 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 doComplete(chatgptCtx, { messages: msgs, 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] ChatGPT browser error for ${model}: ${msg}`);
+        if (!res.headersSent) { res.writeHead(500, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: { message: msg, type: "chatgpt_browser_error" } })); }
+      }
+      return;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+
     // ── CLI runner routing (Gemini / Claude Code) ─────────────────────────────
     let content: string;
     try {