@steipete/oracle 0.9.0 → 0.11.0

package/dist/src/browser/chromeLifecycle.js

@@ -1,26 +1,26 @@
-import { rm } from 'node:fs/promises';
-import { readFileSync } from 'node:fs';
-import os from 'node:os';
-import net from 'node:net';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import CDP from 'chrome-remote-interface';
-import { launch, Launcher } from 'chrome-launcher';
-import { cleanupStaleProfileState } from './profileState.js';
-import { delay } from './utils.js';
+import { rm } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import os from "node:os";
+import net from "node:net";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import CDP from "chrome-remote-interface";
+import { launch, Launcher } from "chrome-launcher";
+import { cleanupStaleProfileState } from "./profileState.js";
+import { delay } from "./utils.js";
 const execFileAsync = promisify(execFile);
 export async function launchChrome(config, userDataDir, logger) {
     const connectHost = resolveRemoteDebugHost();
-    const debugBindAddress = connectHost && connectHost !== '127.0.0.1' ? '0.0.0.0' : connectHost;
+    const debugBindAddress = connectHost && connectHost !== "127.0.0.1" ? "0.0.0.0" : connectHost;
     const debugPort = config.debugPort ?? parseDebugPortEnv();
     const chromeFlags = buildChromeFlags(config.headless ?? false, debugBindAddress);
-    const usePatchedLauncher = Boolean(connectHost && connectHost !== '127.0.0.1');
+    const usePatchedLauncher = Boolean(connectHost && connectHost !== "127.0.0.1");
     const launcher = usePatchedLauncher
         ? await launchWithCustomHost({
             chromeFlags,
             chromePath: config.chromePath ?? undefined,
             userDataDir,
-            host: connectHost ?? '127.0.0.1',
+            host: connectHost ?? "127.0.0.1",
             requestedPort: debugPort ?? undefined,
         })
         : await launch({
@@ -30,13 +30,13 @@ export async function launchChrome(config, userDataDir, logger) {
             handleSIGINT: false,
             port: debugPort ?? undefined,
         });
-    const pidLabel = typeof launcher.pid === 'number' ? ` (pid ${launcher.pid})` : '';
-    const hostLabel = connectHost ? ` on ${connectHost}` : '';
+    const pidLabel = typeof launcher.pid === "number" ? ` (pid ${launcher.pid})` : "";
+    const hostLabel = connectHost ? ` on ${connectHost}` : "";
     logger(`Launched Chrome${pidLabel} on port ${launcher.port}${hostLabel}`);
-    return Object.assign(launcher, { host: connectHost ?? '127.0.0.1' });
+    return Object.assign(launcher, { host: connectHost ?? "127.0.0.1" });
 }
 export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logger, opts) {
-    const signals = ['SIGINT', 'SIGTERM', 'SIGQUIT'];
+    const signals = ["SIGINT", "SIGTERM", "SIGQUIT"];
     let handling;
     const handleSignal = (signal) => {
         if (handling) {
@@ -46,7 +46,7 @@ export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logge
         const inFlight = opts?.isInFlight?.() ?? false;
         const leaveRunning = keepBrowser || inFlight;
         if (leaveRunning) {
-            logger(`Received ${signal}; leaving Chrome running${inFlight ? ' (assistant response pending)' : ''}`);
+            logger(`Received ${signal}; leaving Chrome running${inFlight ? " (assistant response pending)" : ""}`);
         }
         else {
             logger(`Received ${signal}; terminating Chrome process`);
@@ -69,18 +69,18 @@ export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logge
                 if (opts?.preserveUserDataDir) {
                     // Preserve the profile directory (manual login), but clear reattach hints so we don't
                     // try to reuse a dead DevTools port on the next run.
-                    await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: 'never' }).catch(() => undefined);
+                    await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: "never" }).catch(() => undefined);
                 }
                 else {
                     await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
                 }
             }
         })().finally(() => {
-            const exitCode = signal === 'SIGINT' ? 130 : 1;
+            const exitCode = signal === "SIGINT" ? 130 : 1;
             // Vitest treats any `process.exit()` call as an unhandled failure, even if mocked.
             // Keep production behavior (hard-exit on signals) while letting tests observe state changes.
             process.exitCode = exitCode;
-            const isTestRun = process.env.VITEST === '1' || process.env.NODE_ENV === 'test';
+            const isTestRun = process.env.VITEST === "1" || process.env.NODE_ENV === "test";
             if (!isTestRun) {
                 process.exit(exitCode);
             }
@@ -96,12 +96,12 @@ export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logge
     };
 }
 export async function hideChromeWindow(chrome, logger) {
-    if (process.platform !== 'darwin') {
-        logger('Window hiding is only supported on macOS');
+    if (process.platform !== "darwin") {
+        logger("Window hiding is only supported on macOS");
         return;
     }
     if (!chrome.pid) {
-        logger('Unable to hide window: missing Chrome PID');
+        logger("Unable to hide window: missing Chrome PID");
         return;
     }
     const script = `tell application "System Events"
@@ -110,8 +110,8 @@ export async function hideChromeWindow(chrome, logger) {
     end try
   end tell`;
     try {
-        await execFileAsync('osascript', ['-e', script]);
-        logger('Chrome window hidden (Cmd-H)');
+        await execFileAsync("osascript", ["-e", script]);
+        logger("Chrome window hidden (Cmd-H)");
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -120,10 +120,18 @@ export async function hideChromeWindow(chrome, logger) {
 }
 export async function connectToChrome(port, logger, host) {
     const client = await CDP({ port, host });
-    logger('Connected to Chrome DevTools protocol');
+    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,13 +307,63 @@ 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';
+    const effectiveHost = host ?? "127.0.0.1";
+    const url = initialUrl ?? "about:blank";
     const fallbackToDefault = options?.fallbackToDefault ?? true;
     const retries = Math.max(0, options?.retries ?? 0);
     const retryDelayMs = Math.max(0, options?.retryDelayMs ?? 250);
-    const fallbackLabel = fallbackToDefault ? 'falling back to default target.' : 'strict mode: not falling back.';
+    const fallbackLabel = fallbackToDefault
+        ? "falling back to default target."
+        : "strict mode: not falling back.";
     let attempt = 0;
     while (attempt <= retries) {
         const targetConnection = await connectToNewTarget(effectiveHost, port, url, logger, {
@@ -207,13 +382,13 @@ export async function connectWithNewTab(port, logger, initialUrl, host, options)
         await delay(retryDelayMs * attempt);
     }
     if (!fallbackToDefault) {
-        throw new Error('Failed to open isolated browser tab; refusing to attach to default target.');
+        throw new Error("Failed to open isolated browser tab; refusing to attach to default target.");
     }
     const client = await connectToChrome(port, logger, effectiveHost);
     return { client };
 }
 export async function closeTab(port, targetId, logger, host) {
-    const effectiveHost = host ?? '127.0.0.1';
+    const effectiveHost = host ?? "127.0.0.1";
     try {
         await CDP.Close({ host: effectiveHost, port, id: targetId });
         logger(`Closed isolated browser tab (target=${targetId})`);
@@ -223,35 +398,73 @@ 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',
-        '--disable-background-timer-throttling',
-        '--disable-breakpad',
-        '--disable-client-side-phishing-detection',
-        '--disable-default-apps',
-        '--disable-hang-monitor',
-        '--disable-popup-blocking',
-        '--disable-prompt-on-repost',
-        '--disable-sync',
-        '--disable-translate',
-        '--metrics-recording-only',
-        '--no-first-run',
-        '--safebrowsing-disable-auto-update',
-        '--disable-features=TranslateUI,AutomationControlled',
-        '--mute-audio',
-        '--window-size=1280,720',
-        '--lang=en-US',
-        '--accept-lang=en-US,en',
+        "--disable-background-networking",
+        "--disable-background-timer-throttling",
+        "--disable-breakpad",
+        "--disable-client-side-phishing-detection",
+        "--disable-default-apps",
+        "--disable-hang-monitor",
+        "--disable-popup-blocking",
+        "--disable-prompt-on-repost",
+        "--disable-sync",
+        "--disable-translate",
+        "--metrics-recording-only",
+        "--no-first-run",
+        "--safebrowsing-disable-auto-update",
+        "--disable-features=TranslateUI,AutomationControlled",
+        "--mute-audio",
+        "--window-size=1280,720",
+        "--lang=en-US",
+        "--accept-lang=en-US,en",
     ];
-    if (process.platform !== 'win32' && !isWsl()) {
-        flags.push('--password-store=basic', '--use-mock-keychain');
+    if (process.platform !== "win32" && !isWsl()) {
+        flags.push("--password-store=basic", "--use-mock-keychain");
     }
     if (debugBindAddress) {
         flags.push(`--remote-debugging-address=${debugBindAddress}`);
     }
     if (headless) {
-        flags.push('--headless=new');
+        flags.push("--headless=new");
     }
     return flags;
 }
@@ -274,8 +487,8 @@ function resolveRemoteDebugHost() {
         return null;
     }
     try {
-        const resolv = readFileSync('/etc/resolv.conf', 'utf8');
-        for (const line of resolv.split('\n')) {
+        const resolv = readFileSync("/etc/resolv.conf", "utf8");
+        for (const line of resolv.split("\n")) {
             const match = line.match(/^nameserver\s+([0-9.]+)/);
             if (match?.[1]) {
                 return match[1];
@@ -288,14 +501,14 @@ function resolveRemoteDebugHost() {
     return null;
 }
 function isWsl() {
-    if (process.platform !== 'linux') {
+    if (process.platform !== "linux") {
         return false;
     }
     if (process.env.WSL_DISTRO_NAME) {
         return true;
     }
     const release = os.release();
-    return release.toLowerCase().includes('microsoft');
+    return release.toLowerCase().includes("microsoft");
 }
 async function launchWithCustomHost({ chromeFlags, chromePath, userDataDir, host, requestedPort, }) {
     const launcher = new Launcher({
@@ -310,7 +523,7 @@ async function launchWithCustomHost({ chromeFlags, chromePath, userDataDir, host
         patched.isDebuggerReady = function patchedIsDebuggerReady() {
             const debugPort = this.port ?? 0;
             if (!debugPort) {
-                return Promise.reject(new Error('Missing Chrome debug port'));
+                return Promise.reject(new Error("Missing Chrome debug port"));
             }
             return new Promise((resolve, reject) => {
                 const client = net.createConnection({ port: debugPort, host });
@@ -320,11 +533,11 @@ async function launchWithCustomHost({ chromeFlags, chromePath, userDataDir, host
                     client.destroy();
                     client.unref();
                 };
-                client.once('error', (err) => {
+                client.once("error", (err) => {
                     cleanup();
                     reject(err);
                 });
-                client.once('connect', () => {
+                client.once("connect", () => {
                     cleanup();
                     resolve();
                 });

package/dist/src/browser/config.js

@@ -1,12 +1,26 @@
-import { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from './constants.js';
-import { normalizeBrowserModelStrategy } from './modelStrategy.js';
-import { isTemporaryChatUrl, normalizeChatgptUrl } from './utils.js';
-import os from 'node:os';
-import path from 'node:path';
+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";
+export const DEFAULT_CHATGPT_COOKIE_NAMES = [
+    "__Secure-next-auth.session-token",
+    "__Secure-next-auth.session-token.0",
+    "__Secure-next-auth.session-token.1",
+    "_account",
+    "cf_clearance",
+    "__cf_bm",
+    "_cfuvid",
+    "CF_Authorization",
+    "__cflb",
+];
 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,
@@ -16,11 +30,12 @@ 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,
     cookieSync: true,
-    cookieNames: null,
+    cookieNames: DEFAULT_CHATGPT_COOKIE_NAMES,
     cookieSyncWaitMs: 0,
     inlineCookies: null,
     inlineCookiesSource: null,
@@ -32,42 +47,50 @@ 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);
-    const envAllowCookieErrors = (process.env.ORACLE_BROWSER_ALLOW_COOKIE_ERRORS ?? '').trim().toLowerCase() === 'true' ||
-        (process.env.ORACLE_BROWSER_ALLOW_COOKIE_ERRORS ?? '').trim() === '1';
+    const envAllowCookieErrors = (process.env.ORACLE_BROWSER_ALLOW_COOKIE_ERRORS ?? "").trim().toLowerCase() === "true" ||
+        (process.env.ORACLE_BROWSER_ALLOW_COOKIE_ERRORS ?? "").trim() === "1";
     const rawUrl = config?.chatgptUrl ?? config?.url ?? DEFAULT_BROWSER_CONFIG.url;
     const normalizedUrl = normalizeChatgptUrl(rawUrl ?? DEFAULT_BROWSER_CONFIG.url, DEFAULT_BROWSER_CONFIG.url);
     const desiredModel = config?.desiredModel ?? DEFAULT_BROWSER_CONFIG.desiredModel ?? DEFAULT_MODEL_TARGET;
     const modelStrategy = normalizeBrowserModelStrategy(config?.modelStrategy) ??
         DEFAULT_BROWSER_CONFIG.modelStrategy ??
         DEFAULT_MODEL_STRATEGY;
-    if (modelStrategy === 'select' && isTemporaryChatUrl(normalizedUrl) && /\bpro\b/i.test(desiredModel)) {
-        throw new Error('Temporary Chat mode does not expose Pro models in the ChatGPT model picker. ' +
+    if (modelStrategy === "select" &&
+        isTemporaryChatUrl(normalizedUrl) &&
+        /\bpro\b/i.test(desiredModel)) {
+        throw new Error("Temporary Chat mode does not expose Pro models in the ChatGPT model picker. " +
             'Remove "temporary-chat=true" from your browser URL, or use a non-Pro model label (e.g. "GPT-5.2").');
     }
-    const isWindows = process.platform === 'win32';
+    const isWindows = process.platform === "win32";
     const manualLogin = config?.manualLogin ?? (isWindows ? true : DEFAULT_BROWSER_CONFIG.manualLogin);
     const cookieSyncDefault = isWindows ? false : DEFAULT_BROWSER_CONFIG.cookieSync;
-    const resolvedProfileDir = config?.manualLoginProfileDir ??
-        process.env.ORACLE_BROWSER_PROFILE_DIR ??
-        path.join(os.homedir(), '.oracle', 'browser-profile');
+    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 ?? {}),
+        ...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,
@@ -84,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;
@@ -101,3 +136,11 @@ function parseDebugPort(raw) {
     }
     return value;
 }
+function resolveManualLoginProfileDir(...candidates) {
+    for (const candidate of candidates) {
+        const profileDir = candidate?.trim();
+        if (profileDir)
+            return profileDir;
+    }
+    return path.join(os.homedir(), ".oracle", "browser-profile");
+}