@steipete/oracle 0.10.0 → 0.11.0

package/dist/src/browser/chatgptImages.js

@@ -0,0 +1,315 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR } from "./constants.js";
+import { delay } from "./utils.js";
+import { readAssistantSnapshot } from "./pageActions.js";
+import { getOracleHomeDir } from "../oracleHome.js";
+import { resolveSessionArtifactsDir } from "./artifacts.js";
+const GENERATED_IMAGE_WAIT_MIN_MS = 15_000;
+const GENERATED_IMAGE_WAIT_MAX_MS = 15 * 60_000;
+function extractFileId(url) {
+    try {
+        return new URL(url).searchParams.get("id") ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function dedupeImages(images) {
+    const best = new Map();
+    for (const image of images) {
+        const key = image.fileId ?? image.url;
+        const currentArea = (image.width ?? 0) * (image.height ?? 0);
+        const existing = best.get(key);
+        const existingArea = existing ? (existing.width ?? 0) * (existing.height ?? 0) : -1;
+        if (!existing || currentArea >= existingArea) {
+            best.set(key, image);
+        }
+    }
+    return [...best.values()];
+}
+function buildAssistantImageExpression(minTurnIndex) {
+    const minTurnLiteral = typeof minTurnIndex === "number" && Number.isFinite(minTurnIndex) && minTurnIndex >= 0
+        ? Math.floor(minTurnIndex)
+        : -1;
+    const conversationLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    const assistantLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
+    return `(() => {
+    const MIN_TURN_INDEX = ${minTurnLiteral};
+    const CONVERSATION_SELECTOR = ${conversationLiteral};
+    const ASSISTANT_SELECTOR = ${assistantLiteral};
+    const isGeneratedImage = (img) => {
+      const url = img?.src || '';
+      if (!url.includes('/backend-api/estuary/content?id=file_')) return false;
+      const alt = String(img.alt || '').toLowerCase();
+      if (alt.includes('generated image')) return true;
+      let node = img;
+      while (node instanceof HTMLElement) {
+        if (String(node.id || '').startsWith('image-')) return true;
+        if (String(node.className || '').includes('imagegen-image')) return true;
+        node = node.parentElement;
+      }
+      return false;
+    };
+    const serializeImages = (root) =>
+      Array.from(root.querySelectorAll('img')).filter(isGeneratedImage).map((img) => ({
+        url: img.src || '',
+        alt: img.alt || '',
+        width: img.naturalWidth || 0,
+        height: img.naturalHeight || 0,
+      }));
+    const isAssistantTurn = (node) => {
+      if (!(node instanceof HTMLElement)) return false;
+      const turnAttr = (node.getAttribute('data-turn') || node.dataset?.turn || '').toLowerCase();
+      if (turnAttr === 'assistant') return true;
+      const role = (node.getAttribute('data-message-author-role') || node.dataset?.messageAuthorRole || '').toLowerCase();
+      if (role === 'assistant') return true;
+      const testId = (node.getAttribute('data-testid') || '').toLowerCase();
+      if (testId.includes('assistant')) return true;
+      return Boolean(node.querySelector(ASSISTANT_SELECTOR) || node.querySelector('[data-testid*="assistant"]'));
+    };
+    const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+    for (let index = turns.length - 1; index >= 0; index -= 1) {
+      const turn = turns[index];
+      if (!isAssistantTurn(turn)) continue;
+      if (MIN_TURN_INDEX >= 0 && index < MIN_TURN_INDEX) continue;
+      const messageRoot = turn.querySelector(ASSISTANT_SELECTOR) || turn;
+      const images = serializeImages(messageRoot);
+      if (images.length > 0) return images;
+    }
+    const boundary =
+      MIN_TURN_INDEX > 0 && turns.length > 0
+        ? turns[Math.min(MIN_TURN_INDEX - 1, turns.length - 1)]
+        : null;
+    return Array.from(document.querySelectorAll('img'))
+      .filter(isGeneratedImage)
+      .filter((img) => {
+        if (!boundary) return true;
+        return Boolean(boundary.compareDocumentPosition(img) & Node.DOCUMENT_POSITION_FOLLOWING);
+      })
+      .map((img) => ({
+        url: img.src || '',
+        alt: img.alt || '',
+        width: img.naturalWidth || 0,
+        height: img.naturalHeight || 0,
+      }));
+  })()`;
+}
+export async function readAssistantGeneratedImages(Runtime, minTurnIndex) {
+    const { result } = await Runtime.evaluate({
+        expression: buildAssistantImageExpression(minTurnIndex),
+        returnByValue: true,
+    });
+    const raw = Array.isArray(result?.value) ? result.value : [];
+    const normalized = raw
+        .map((item) => ({
+        url: typeof item?.url === "string" ? item.url : "",
+        alt: typeof item?.alt === "string" ? item.alt : undefined,
+        width: typeof item?.width === "number" ? item.width : undefined,
+        height: typeof item?.height === "number" ? item.height : undefined,
+        fileId: typeof item?.url === "string" ? extractFileId(item.url) : undefined,
+    }))
+        .filter((item) => item.url.length > 0);
+    return dedupeImages(normalized);
+}
+async function readAssistantGeneratedImagesWithFallback(Runtime, minTurnIndex) {
+    const filteredImages = await readAssistantGeneratedImages(Runtime, minTurnIndex ?? undefined).catch(() => []);
+    if (filteredImages.length > 0 ||
+        typeof minTurnIndex !== "number" ||
+        !Number.isFinite(minTurnIndex)) {
+        return filteredImages;
+    }
+    const [fallbackImages, fallbackSnapshot] = await Promise.all([
+        readAssistantGeneratedImages(Runtime).catch(() => []),
+        readAssistantSnapshot(Runtime).catch(() => null),
+    ]);
+    const fallbackTurnIndex = typeof fallbackSnapshot?.turnIndex === "number" ? fallbackSnapshot.turnIndex : null;
+    const nearBoundary = fallbackTurnIndex !== null && fallbackTurnIndex + 1 >= Math.floor(minTurnIndex);
+    return fallbackImages.length > 0 && nearBoundary ? fallbackImages : [];
+}
+function resolveGeneratedImageWaitTimeoutMs(waitTimeoutMs) {
+    const requestedTimeout = typeof waitTimeoutMs === "number" && Number.isFinite(waitTimeoutMs)
+        ? waitTimeoutMs
+        : GENERATED_IMAGE_WAIT_MAX_MS;
+    return Math.max(GENERATED_IMAGE_WAIT_MIN_MS, Math.min(requestedTimeout, GENERATED_IMAGE_WAIT_MAX_MS));
+}
+export function resolveGeneratedImageWaitTimeoutMsForTest(waitTimeoutMs) {
+    return resolveGeneratedImageWaitTimeoutMs(waitTimeoutMs);
+}
+function contentTypeToExtension(contentType) {
+    const value = String(contentType ?? "").toLowerCase();
+    if (value.includes("png"))
+        return "png";
+    if (value.includes("jpeg") || value.includes("jpg"))
+        return "jpg";
+    if (value.includes("webp"))
+        return "webp";
+    if (value.includes("gif"))
+        return "gif";
+    if (value.includes("svg"))
+        return "svg";
+    return "bin";
+}
+function resolveSiblingImagePath(basePath, index, extension) {
+    const ext = path.extname(basePath);
+    const dir = path.dirname(basePath);
+    const stem = ext ? path.basename(basePath, ext) : path.basename(basePath);
+    if (index === 0) {
+        return ext ? basePath : path.join(dir, `${stem}.${extension}`);
+    }
+    const suffix = ext ? `${stem}.${index + 1}${ext}` : `${stem}.${index + 1}.${extension}`;
+    return path.join(dir, suffix);
+}
+function sanitizeGeneratedImageStem(value) {
+    return value
+        .replace(/[^a-zA-Z0-9_-]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "")
+        .slice(0, 48);
+}
+function resolveDefaultGeneratedImagePath(images, sessionId) {
+    const primary = images[0];
+    const stemSource = primary?.fileId || primary?.alt || primary?.url || `generated-${Date.now().toString(36)}`;
+    const stem = sanitizeGeneratedImageStem(stemSource) || `generated-${Date.now().toString(36)}`;
+    const baseDir = sessionId
+        ? resolveSessionArtifactsDir(sessionId)
+        : path.join(getOracleHomeDir(), ".temp");
+    return path.join(baseDir, `${stem}.png`);
+}
+async function buildCookieHeader(Network) {
+    const response = await Network.getCookies({ urls: ["https://chatgpt.com/"] });
+    return (response.cookies ?? [])
+        .filter((cookie) => cookie.name && typeof cookie.value === "string")
+        .map((cookie) => `${cookie.name}=${cookie.value}`)
+        .join("; ");
+}
+export async function saveChatGptGeneratedImages(params) {
+    const { Network, images, outputPath, logger } = params;
+    if (!images.length)
+        return { saved: false, imageCount: 0, savedImages: [], errors: [] };
+    const cookieHeader = await buildCookieHeader(Network);
+    if (!cookieHeader) {
+        return {
+            saved: false,
+            imageCount: images.length,
+            savedImages: [],
+            errors: ["Missing ChatGPT cookies for image download."],
+        };
+    }
+    const savedImages = [];
+    const errors = [];
+    await fs.mkdir(path.dirname(path.resolve(outputPath)), { recursive: true });
+    for (let index = 0; index < images.length; index += 1) {
+        const image = images[index];
+        try {
+            const response = await fetch(image.url, {
+                headers: {
+                    cookie: cookieHeader,
+                    "user-agent": "Mozilla/5.0",
+                },
+                redirect: "follow",
+            });
+            if (!response.ok) {
+                throw new Error(`download failed: ${response.status} ${response.statusText}`);
+            }
+            const contentType = response.headers.get("content-type");
+            const extension = contentTypeToExtension(contentType);
+            const targetPath = resolveSiblingImagePath(path.resolve(outputPath), index, extension);
+            const buffer = Buffer.from(await response.arrayBuffer());
+            await fs.writeFile(targetPath, buffer);
+            savedImages.push({
+                kind: "image",
+                path: targetPath,
+                label: index === 0 ? "Generated image" : `Generated image ${index + 1}`,
+                mimeType: contentType ?? undefined,
+                sizeBytes: buffer.length,
+                sourceUrl: image.url,
+                url: image.url,
+                finalUrl: response.url,
+                alt: image.alt,
+                width: image.width,
+                height: image.height,
+                fileId: image.fileId,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            errors.push(`${image.fileId ?? image.url}: ${message}`);
+            logger?.(`[browser] Failed to save generated image ${index + 1}/${images.length}: ${message}`);
+        }
+    }
+    return {
+        saved: savedImages.length > 0,
+        imageCount: images.length,
+        savedImages,
+        errors,
+    };
+}
+export async function collectGeneratedImageArtifacts(params) {
+    const explicitTargetPath = params.generateImagePath ?? params.outputPath;
+    let generatedImages = await readAssistantGeneratedImagesWithFallback(params.Runtime, params.minTurnIndex ?? undefined);
+    let latestAnswerText = params.answerText;
+    if (explicitTargetPath && generatedImages.length === 0) {
+        const deadline = Date.now() + resolveGeneratedImageWaitTimeoutMs(params.waitTimeoutMs);
+        while (Date.now() < deadline) {
+            await delay(1500);
+            generatedImages = await readAssistantGeneratedImagesWithFallback(params.Runtime, params.minTurnIndex ?? undefined);
+            if (generatedImages.length > 0) {
+                break;
+            }
+            const latestSnapshot = await readAssistantSnapshot(params.Runtime, params.minTurnIndex ?? undefined).catch(() => null);
+            const snapshotText = typeof latestSnapshot?.text === "string" ? latestSnapshot.text.trim() : "";
+            if (snapshotText) {
+                latestAnswerText = snapshotText;
+            }
+        }
+    }
+    const imageCount = generatedImages.length;
+    if (explicitTargetPath && imageCount === 0) {
+        throw new Error(`No images generated. Response text:\n${latestAnswerText || "(empty response)"}`);
+    }
+    if (imageCount === 0) {
+        return {
+            generatedImages,
+            savedImages: [],
+            imageCount,
+            markdownSuffix: "",
+            answerText: latestAnswerText,
+        };
+    }
+    const targetPath = explicitTargetPath ?? resolveDefaultGeneratedImagePath(generatedImages, params.sessionId);
+    if (!explicitTargetPath) {
+        params.logger?.(`[browser] Auto-saving generated images to ${targetPath}`);
+    }
+    const saved = await saveChatGptGeneratedImages({
+        Network: params.Network,
+        images: generatedImages,
+        outputPath: targetPath,
+        logger: params.logger,
+    });
+    if (!saved.saved) {
+        const detail = saved.errors.length > 0 ? `\n${saved.errors.join("\n")}` : "";
+        if (explicitTargetPath) {
+            throw new Error(`No images generated. Response text:\n${latestAnswerText || "(empty response)"}${detail}`);
+        }
+        params.logger?.(`[browser] Auto-save for generated images failed; returning metadata only.${detail}`);
+        return {
+            generatedImages,
+            savedImages: [],
+            imageCount,
+            markdownSuffix: `\n\n*Generated ${imageCount} image(s).*`,
+            answerText: latestAnswerText,
+        };
+    }
+    const primaryPath = saved.savedImages[0]?.path ?? targetPath;
+    const suffix = saved.savedImages.length > 1
+        ? `\n\n*Generated ${saved.imageCount} image(s). Saved ${saved.savedImages.length} file(s) starting at: ${primaryPath}*`
+        : `\n\n*Generated ${saved.imageCount} image(s). Saved to: ${primaryPath}*`;
+    return {
+        generatedImages,
+        savedImages: saved.savedImages,
+        imageCount: saved.imageCount,
+        markdownSuffix: suffix,
+        answerText: latestAnswerText,
+    };
+}

package/dist/src/browser/chromeLifecycle.js

@@ -123,7 +123,15 @@ export async function connectToChrome(port, logger, host) {
     logger("Connected to Chrome DevTools protocol");
     return client;
 }
-export async function connectToRemoteChrome(host, port, logger, targetUrl) {
+export async function connectToRemoteChrome(host, port, logger, targetUrl, browserWSEndpoint, options) {
+    if (browserWSEndpoint) {
+        return await connectToRemoteChromeTarget(host, port, logger, {
+            browserWSEndpoint,
+            targetUrl: targetUrl ?? "about:blank",
+            closeTargetOnDispose: true,
+            approvalWaitMs: options?.approvalWaitMs,
+        });
+    }
     if (targetUrl) {
         const targetConnection = await connectToNewTarget(host, port, targetUrl, logger, {
             opened: () => `Opened dedicated remote Chrome tab targeting ${targetUrl}`,
@@ -132,12 +140,24 @@ export async function connectToRemoteChrome(host, port, logger, targetUrl) {
             closeFailed: (targetId, message) => `Failed to close unused remote Chrome tab ${targetId}: ${message}`,
         });
         if (targetConnection) {
-            return { client: targetConnection.client, targetId: targetConnection.targetId };
+            return {
+                client: targetConnection.client,
+                targetId: targetConnection.targetId,
+                close: async () => {
+                    await targetConnection.client.close().catch(() => undefined);
+                    await closeRemoteChromeTarget(host, port, targetConnection.targetId, logger);
+                },
+            };
         }
     }
     const fallbackClient = await CDP({ host, port });
     logger(`Connected to remote Chrome DevTools protocol at ${host}:${port}`);
-    return { client: fallbackClient };
+    return {
+        client: fallbackClient,
+        close: async () => {
+            await fallbackClient.close().catch(() => undefined);
+        },
+    };
 }
 export async function closeRemoteChromeTarget(host, port, targetId, logger) {
     if (!targetId) {
@@ -154,6 +174,111 @@ export async function closeRemoteChromeTarget(host, port, targetId, logger) {
         logger(`Failed to close remote Chrome tab ${targetId}: ${message}`);
     }
 }
+export async function listRemoteChromeTargets(options) {
+    if (!options.browserWSEndpoint) {
+        const targets = await CDP.List({ host: options.host, port: options.port });
+        return targets;
+    }
+    const browser = await CDP({ target: options.browserWSEndpoint, local: true });
+    try {
+        const result = await browser.Target.getTargets();
+        return (result.targetInfos ?? []).map((target) => ({
+            targetId: target.targetId,
+            type: target.type,
+            url: target.url,
+        }));
+    }
+    finally {
+        await browser.close().catch(() => undefined);
+    }
+}
+export async function connectToRemoteChromeTarget(host, port, logger, options) {
+    if (!options.browserWSEndpoint) {
+        const client = await CDP({ host, port, target: options.targetId });
+        return {
+            client,
+            targetId: options.targetId,
+            close: async () => {
+                await client.close().catch(() => undefined);
+            },
+        };
+    }
+    const browser = await connectToBrowserWebSocket(host, port, options.browserWSEndpoint, logger, options.approvalWaitMs);
+    let targetId = options.targetId;
+    try {
+        if (!targetId) {
+            const created = await browser.Target.createTarget({
+                url: options.targetUrl ?? "about:blank",
+            });
+            targetId = created.targetId;
+            logger(`Opened dedicated remote Chrome tab targeting ${options.targetUrl ?? "about:blank"}`);
+        }
+        const attached = await browser.Target.attachToTarget({ targetId, flatten: true });
+        const client = createSessionBoundChromeClient(browser, attached.sessionId);
+        return {
+            client,
+            targetId,
+            browserWSEndpoint: options.browserWSEndpoint,
+            close: async () => {
+                await browser.Target.detachFromTarget({ sessionId: attached.sessionId }).catch(() => undefined);
+                if (options.closeTargetOnDispose && targetId) {
+                    await browser.Target.closeTarget({ targetId }).catch(() => undefined);
+                }
+                await browser.close().catch(() => undefined);
+            },
+        };
+    }
+    catch (error) {
+        await browser.close().catch(() => undefined);
+        throw error;
+    }
+}
+async function connectToBrowserWebSocket(host, port, browserWSEndpoint, logger, approvalWaitMs) {
+    if (!approvalWaitMs || approvalWaitMs <= 0) {
+        return (await CDP({ target: browserWSEndpoint, local: true }));
+    }
+    logger(`Waiting for Chrome remote debugging approval for ${host}:${port}...`);
+    const deadline = Date.now() + approvalWaitMs;
+    let lastApprovalError;
+    while (Date.now() < deadline) {
+        const remainingMs = Math.max(1, deadline - Date.now());
+        try {
+            return await Promise.race([
+                CDP({ target: browserWSEndpoint, local: true }),
+                new Promise((_, reject) => {
+                    setTimeout(() => {
+                        reject(new Error("__oracle_remote_debugging_approval_timeout__"));
+                    }, remainingMs);
+                }),
+            ]);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message === "__oracle_remote_debugging_approval_timeout__") {
+                break;
+            }
+            if (!isRemoteDebuggingApprovalError(error)) {
+                throw error;
+            }
+            lastApprovalError = error;
+            await delay(Math.min(500, Math.max(0, deadline - Date.now())));
+        }
+    }
+    const suffix = lastApprovalError instanceof Error && lastApprovalError.message
+        ? ` Last Chrome response: ${lastApprovalError.message}`
+        : "";
+    throw new Error(`Oracle waited ${formatApprovalWait(approvalWaitMs)} for Chrome remote debugging approval at ${host}:${port}. Allow the Chrome prompt or retry after toggling remote debugging.${suffix}`);
+}
+function isRemoteDebuggingApprovalError(error) {
+    const message = error instanceof Error ? error.message : String(error ?? "");
+    return /unexpected server response:\s*403|remote debugging|forbidden/i.test(message);
+}
+function formatApprovalWait(waitMs) {
+    if (waitMs % 1000 === 0) {
+        return `${waitMs / 1000}s`;
+    }
+    return `${waitMs}ms`;
+}
 async function connectToNewTarget(host, port, url, logger, messages) {
     try {
         const target = await CDP.New({ host, port, url });
@@ -182,6 +307,54 @@ async function connectToNewTarget(host, port, url, logger, messages) {
     }
     return null;
 }
+function createSessionBoundChromeClient(browser, sessionId) {
+    const browserWithEvents = browser;
+    const bindDomain = (domainName) => {
+        const domain = browser[domainName];
+        const eventName = (name) => `${domainName}.${name}.${sessionId}`;
+        return new Proxy((domain ?? {}), {
+            get(target, prop, receiver) {
+                if (prop === "on") {
+                    return (name, listener) => {
+                        const domainEvent = target[name];
+                        if (typeof domainEvent === "function") {
+                            return domainEvent(sessionId, listener);
+                        }
+                        browserWithEvents.on(eventName(name), listener);
+                        return () => browserWithEvents.removeListener(eventName(name), listener);
+                    };
+                }
+                if (prop === "off" || prop === "removeListener") {
+                    return (name, listener) => {
+                        const off = browserWithEvents.off ?? browserWithEvents.removeListener.bind(browserWithEvents);
+                        off(eventName(name), listener);
+                    };
+                }
+                const value = Reflect.get(target, prop, receiver);
+                if (typeof value !== "function") {
+                    return value;
+                }
+                return (...args) => value(...args, sessionId);
+            },
+        });
+    };
+    return {
+        ...browser,
+        Network: bindDomain("Network"),
+        Page: bindDomain("Page"),
+        Runtime: bindDomain("Runtime"),
+        Input: bindDomain("Input"),
+        DOM: bindDomain("DOM"),
+        on: browserWithEvents.on.bind(browserWithEvents),
+        once: browserWithEvents.once.bind(browserWithEvents),
+        off: browserWithEvents.off?.bind(browserWithEvents) ??
+            browserWithEvents.removeListener.bind(browserWithEvents),
+        removeListener: browserWithEvents.removeListener.bind(browserWithEvents),
+        close: async () => {
+            await browser.Target.detachFromTarget({ sessionId }).catch(() => undefined);
+        },
+    };
+}
 export async function connectWithNewTab(port, logger, initialUrl, host, options) {
     const effectiveHost = host ?? "127.0.0.1";
     const url = initialUrl ?? "about:blank";
@@ -225,6 +398,44 @@ export async function closeTab(port, targetId, logger, host) {
         logger(`Failed to close browser tab ${targetId}: ${message}`);
     }
 }
+export async function closeBlankChromeTabs(port, logger, host, options) {
+    const effectiveHost = host ?? "127.0.0.1";
+    const excluded = new Set([...(options?.excludeTargetIds ?? [])].filter((targetId) => typeof targetId === "string" && targetId.length > 0));
+    let targets;
+    try {
+        targets = (await CDP.List({ host: effectiveHost, port }));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Failed to inspect blank Chrome tabs: ${message}`);
+        return;
+    }
+    let closed = 0;
+    for (const target of targets) {
+        const targetId = target.targetId ?? target.id;
+        if (!targetId || excluded.has(targetId) || !isBlankPageTarget(target)) {
+            continue;
+        }
+        try {
+            await CDP.Close({ host: effectiveHost, port, id: targetId });
+            closed += 1;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger(`Failed to close blank Chrome tab ${targetId}: ${message}`);
+        }
+    }
+    if (closed > 0) {
+        logger(`Closed ${closed} blank Chrome tab${closed === 1 ? "" : "s"}.`);
+    }
+}
+function isBlankPageTarget(target) {
+    if (target.type && target.type !== "page") {
+        return false;
+    }
+    const url = (target.url ?? "").trim().toLowerCase();
+    return url === "about:blank" || url === "chrome://newtab/" || url === "chrome://new-tab-page/";
+}
 function buildChromeFlags(headless, debugBindAddress) {
     const flags = [
         "--disable-background-networking",

package/dist/src/browser/config.js

@@ -1,5 +1,6 @@
-import { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "./constants.js";
+import { CHATGPT_URL, DEEP_RESEARCH_DEFAULT_TIMEOUT_MS, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET, } from "./constants.js";
 import { normalizeBrowserModelStrategy } from "./modelStrategy.js";
+import { DEFAULT_MAX_CONCURRENT_CHATGPT_TABS, normalizeMaxConcurrentTabs, } from "./tabLeaseRegistry.js";
 import { isTemporaryChatUrl, normalizeChatgptUrl } from "./utils.js";
 import os from "node:os";
 import path from "node:path";
@@ -18,6 +19,8 @@ export const DEFAULT_BROWSER_CONFIG = {
     chromeProfile: null,
     chromePath: null,
     chromeCookiePath: null,
+    attachRunning: false,
+    browserTabRef: null,
     url: CHATGPT_URL,
     chatgptUrl: CHATGPT_URL,
     timeoutMs: 1_200_000,
@@ -27,6 +30,7 @@ export const DEFAULT_BROWSER_CONFIG = {
     assistantRecheckTimeoutMs: 120_000,
     reuseChromeWaitMs: 10_000,
     profileLockTimeoutMs: 300_000,
+    maxConcurrentTabs: DEFAULT_MAX_CONCURRENT_CHATGPT_TABS,
     autoReattachDelayMs: 0,
     autoReattachIntervalMs: 0,
     autoReattachTimeoutMs: 120_000,
@@ -43,9 +47,13 @@ export const DEFAULT_BROWSER_CONFIG = {
     debug: false,
     allowCookieErrors: false,
     remoteChrome: null,
+    remoteChromeBrowserWSEndpoint: null,
+    remoteChromeProfileRoot: null,
     manualLogin: false,
     manualLoginProfileDir: null,
     manualLoginCookieSync: false,
+    researchMode: "off",
+    archiveConversations: "auto",
 };
 export function resolveBrowserConfig(config) {
     const debugPortEnv = parseDebugPort(process.env.ORACLE_BROWSER_PORT ?? process.env.ORACLE_BROWSER_DEBUG_PORT);
@@ -67,18 +75,22 @@ export function resolveBrowserConfig(config) {
     const manualLogin = config?.manualLogin ?? (isWindows ? true : DEFAULT_BROWSER_CONFIG.manualLogin);
     const cookieSyncDefault = isWindows ? false : DEFAULT_BROWSER_CONFIG.cookieSync;
     const resolvedProfileDir = resolveManualLoginProfileDir(config?.manualLoginProfileDir, process.env.ORACLE_BROWSER_PROFILE_DIR);
+    const researchMode = normalizeResearchMode(config?.researchMode);
+    const archiveConversations = normalizeArchiveMode(config?.archiveConversations);
+    const defaultTimeoutMs = researchMode === "deep" ? DEEP_RESEARCH_DEFAULT_TIMEOUT_MS : DEFAULT_BROWSER_CONFIG.timeoutMs;
     return {
         ...DEFAULT_BROWSER_CONFIG,
         ...config,
         url: normalizedUrl,
         chatgptUrl: normalizedUrl,
-        timeoutMs: config?.timeoutMs ?? DEFAULT_BROWSER_CONFIG.timeoutMs,
+        timeoutMs: config?.timeoutMs ?? defaultTimeoutMs,
         debugPort: config?.debugPort ?? debugPortEnv ?? DEFAULT_BROWSER_CONFIG.debugPort,
         inputTimeoutMs: config?.inputTimeoutMs ?? DEFAULT_BROWSER_CONFIG.inputTimeoutMs,
         assistantRecheckDelayMs: config?.assistantRecheckDelayMs ?? DEFAULT_BROWSER_CONFIG.assistantRecheckDelayMs,
         assistantRecheckTimeoutMs: config?.assistantRecheckTimeoutMs ?? DEFAULT_BROWSER_CONFIG.assistantRecheckTimeoutMs,
         reuseChromeWaitMs: config?.reuseChromeWaitMs ?? DEFAULT_BROWSER_CONFIG.reuseChromeWaitMs,
         profileLockTimeoutMs: config?.profileLockTimeoutMs ?? DEFAULT_BROWSER_CONFIG.profileLockTimeoutMs,
+        maxConcurrentTabs: normalizeMaxConcurrentTabs(config?.maxConcurrentTabs ?? DEFAULT_BROWSER_CONFIG.maxConcurrentTabs),
         autoReattachDelayMs: config?.autoReattachDelayMs ?? DEFAULT_BROWSER_CONFIG.autoReattachDelayMs,
         autoReattachIntervalMs: config?.autoReattachIntervalMs ?? DEFAULT_BROWSER_CONFIG.autoReattachIntervalMs,
         autoReattachTimeoutMs: config?.autoReattachTimeoutMs ?? DEFAULT_BROWSER_CONFIG.autoReattachTimeoutMs,
@@ -95,14 +107,26 @@ export function resolveBrowserConfig(config) {
         chromeProfile: config?.chromeProfile ?? DEFAULT_BROWSER_CONFIG.chromeProfile,
         chromePath: config?.chromePath ?? DEFAULT_BROWSER_CONFIG.chromePath,
         chromeCookiePath: config?.chromeCookiePath ?? DEFAULT_BROWSER_CONFIG.chromeCookiePath,
+        attachRunning: config?.attachRunning ?? DEFAULT_BROWSER_CONFIG.attachRunning,
+        browserTabRef: config?.browserTabRef ?? DEFAULT_BROWSER_CONFIG.browserTabRef,
         debug: config?.debug ?? DEFAULT_BROWSER_CONFIG.debug,
         allowCookieErrors: config?.allowCookieErrors ?? envAllowCookieErrors ?? DEFAULT_BROWSER_CONFIG.allowCookieErrors,
+        remoteChromeBrowserWSEndpoint: config?.remoteChromeBrowserWSEndpoint ?? DEFAULT_BROWSER_CONFIG.remoteChromeBrowserWSEndpoint,
+        remoteChromeProfileRoot: config?.remoteChromeProfileRoot ?? DEFAULT_BROWSER_CONFIG.remoteChromeProfileRoot,
         thinkingTime: config?.thinkingTime,
+        researchMode,
+        archiveConversations,
         manualLogin,
         manualLoginProfileDir: manualLogin ? resolvedProfileDir : null,
         manualLoginCookieSync: config?.manualLoginCookieSync ?? DEFAULT_BROWSER_CONFIG.manualLoginCookieSync,
     };
 }
+function normalizeResearchMode(value) {
+    return value === "deep" ? "deep" : "off";
+}
+function normalizeArchiveMode(value) {
+    return value === "always" || value === "never" ? value : "auto";
+}
 function parseDebugPort(raw) {
     if (!raw)
         return null;

package/dist/src/browser/constants.js

@@ -9,11 +9,13 @@ export const COOKIE_URLS = [
 export const INPUT_SELECTORS = [
     'textarea[data-id="prompt-textarea"]',
     'textarea[placeholder*="Send a message"]',
+    'textarea[aria-label="Chat with ChatGPT"]',
     'textarea[aria-label="Message ChatGPT"]',
     "textarea:not([disabled])",
     'textarea[name="prompt-textarea"]',
     "#prompt-textarea",
     ".ProseMirror",
+    '[contenteditable="true"][role="textbox"]',
     '[contenteditable="true"][data-virtualkeyboard="true"]',
 ];
 export const ANSWER_SELECTORS = [
@@ -73,4 +75,10 @@ export const MODEL_BUTTON_SELECTOR = '[data-testid="model-switcher-dropdown-butt
 export const COMPOSER_MODEL_SIGNAL_SELECTOR = '[data-testid="composer-footer-actions"]';
 export const COPY_BUTTON_SELECTOR = 'button[data-testid="copy-turn-action-button"]';
 // Action buttons that only appear once a turn has finished rendering.
+export const DEEP_RESEARCH_PLUS_BUTTON = '[data-testid="composer-plus-btn"]';
+export const DEEP_RESEARCH_DROPDOWN_ITEM_TEXT = "Deep research";
+export const DEEP_RESEARCH_PILL_LABEL = "Deep research";
+export const DEEP_RESEARCH_POLL_INTERVAL_MS = 5_000;
+export const DEEP_RESEARCH_AUTO_CONFIRM_WAIT_MS = 70_000;
+export const DEEP_RESEARCH_DEFAULT_TIMEOUT_MS = 2_400_000;
 export const FINISHED_ACTIONS_SELECTOR = 'button[data-testid="copy-turn-action-button"], button[data-testid="good-response-turn-action-button"], button[data-testid="bad-response-turn-action-button"], button[aria-label="Share"]';