@steipete/oracle 0.19.0 → 0.20.1

package/dist/src/browser/actions/modelSelection.js

@@ -81,6 +81,15 @@ function assertResolvedModelSelection(desiredModel, resolvedLabel) {
     const resolved = resolvedLabel.toLowerCase();
     const normalizedDesired = normalizeResolvedModelLabel(desired);
     const normalizedResolved = normalizeResolvedModelLabel(resolved);
+    if (desired === "latest") {
+        // The advanced radio is localized, but only the documented exact labels are
+        // evidence of GPT-6 Astra. Do not let a generic picker result verify Latest.
+        if (resolvedLabel.normalize("NFC").trim() === "Latest" ||
+            resolvedLabel.normalize("NFC").trim() === "最新") {
+            return;
+        }
+        throw new Error(`Model picker selected "${resolvedLabel}" while "${desiredModel}" requires GPT-6 Astra (Latest).`);
+    }
     const wantsGpt56Sol = /(?:^| )5 6(?: |$)/.test(normalizedDesired) && normalizedDesired.split(" ").includes("sol");
     if (wantsGpt56Sol) {
         const resolvedTokens = normalizedResolved.split(" ");
@@ -169,6 +178,17 @@ function buildModelSelectionExpression(targetModel, strategy) {
     const hasToken = (value, token) => normalizeText(value).split(' ').includes(token);
     // Normalize every candidate token to keep fuzzy matching deterministic.
     const normalizedTarget = normalizeText(PRIMARY_LABEL);
+    // "Latest" (GPT-6 since 2026-09) is a radio in the advanced view whose composer pill reads
+    // "6 Pro" / "6 High"…, while GPT-5.6 Sol's reads "5.6 Pro". Declared up front: getResolvedLabel
+    // runs on the picker-less path before the selection helpers below are initialized.
+    const targetIsLatest = normalizedTarget === 'latest';
+    // ChatGPT localizes the Latest radio itself (for example, Japanese "最新") but
+    // keeps the GPT-6 composer pill numeric. Keep this allow-list exact so GPT-5.6
+    // Sol or an arbitrary localized menu row can never satisfy a Latest request.
+    const isLatestModelLabel = (value) => {
+      const label = String(value ?? '').normalize('NFC').trim();
+      return label === 'Latest' || label === '最新';
+    };
     const normalizedTokens = Array.from(new Set([normalizedTarget, ...LABEL_TOKENS]))
       .map((token) => normalizeText(token))
       .filter(Boolean);
@@ -310,6 +330,14 @@ function buildModelSelectionExpression(targetModel, strategy) {
     };
 
     const getButtonLabel = () => (findModelButton()?.textContent ?? '').trim();
+    // With the picker closed the only evidence for "Latest" is the composer pill, so a version-less
+    // "latest" target must be decided on it: the blank composer signal would otherwise pass as
+    // "already selected" while GPT-5.6 Sol is active. Defined here, before getResolvedLabel, because
+    // the "current" strategy resolves the label before the selection helpers further down exist.
+    const latestButtonSelected = () => {
+      const label = normalizeText(getButtonLabel());
+      return /^(chatgpt |gpt )?6(?![0-9 .]*[0-9])/.test(label) && !/(^| )5 6/.test(label);
+    };
     const getComposerModelLabel = () =>
       (document.querySelector(COMPOSER_MODEL_SIGNAL_SELECTOR)?.textContent ?? '').trim();
     const readComposerModelSignal = () => normalizeText(getComposerModelLabel());
@@ -481,15 +509,37 @@ function buildModelSelectionExpression(targetModel, strategy) {
       if (wantsInstant) return label.includes('instant');
       if (wantsThinking) return Boolean(desiredVersion) && !labelHasProWord(label);
       if (desiredVersion) return true;
+      // A version-less target ("Latest") must match the radio that is actually checked in the
+      // advanced view: the opener's text lists every radio label, so a substring test would
+      // report "Latest" as selected while GPT-5.6 Sol is the checked model.
+      const checkedAdvancedRadio = findCheckedAdvancedModelRadio(parentMenu);
+      if (checkedAdvancedRadio) {
+        const checkedLabel = checkedAdvancedRadio.textContent ?? '';
+        return targetIsLatest
+          ? isLatestModelLabel(checkedLabel)
+          : normalizedTokens.some((token) => token && normalizeText(checkedLabel) === token);
+      }
       return normalizedTokens.some((token) => token && label.includes(token));
     };
+    const findCheckedAdvancedModelRadio = (menu = null) => {
+      const scope = menu || findUnifiedPickerMenu() || document;
+      return (
+        scope?.querySelector?.(
+          '[data-testid="composer-model-picker-slider-advanced-view"] [role="menuitemradio"][aria-checked="true"]',
+        ) ?? null
+      );
+    };
     const getAdvancedModelLabel = () => {
       const opener = findModelSubmenuOpener(findUnifiedPickerMenu());
       if (!opener) return '';
       const raw = (opener.textContent ?? '').trim();
       const normalized = normalizeText(pickerNodeLabel(opener));
       const version = versionFromLabel(normalized);
-      if (!version) return raw;
+      if (!version) {
+        const checkedAdvancedRadio = findCheckedAdvancedModelRadio(findUnifiedPickerMenu());
+        const checkedLabel = (checkedAdvancedRadio?.textContent ?? '').trim();
+        return checkedLabel || raw;
+      }
       const [major, minor] = version.split('-');
       const suffix = normalized.split(' ').includes('sol') ? ' Sol' : '';
       return 'GPT-' + major + '.' + minor + suffix;
@@ -503,6 +553,17 @@ function buildModelSelectionExpression(targetModel, strategy) {
       );
     };
     const getResolvedLabel = (observedOptionLabel = '') => {
+      if (targetIsLatest) {
+        const checkedAdvancedRadio = findCheckedAdvancedModelRadio();
+        if (checkedAdvancedRadio) return (checkedAdvancedRadio.textContent ?? '').trim();
+        // Picker closed: the pill ("6 Pro") is the evidence; report the radio's name so callers
+        // can compare against the requested target instead of the tier-suffixed pill text.
+        if (latestButtonSelected()) return 'Latest';
+        const currentButtonLabel = getButtonLabel();
+        if (currentButtonLabel) return currentButtonLabel;
+        // No picker button at all (e.g. the "current" strategy on a page that hides it): fall back
+        // to the generic composer/observed label resolution below.
+      }
       if (configuredSelectionMatchesTarget()) {
         const variant = getConfiguredVariantLabel();
         const version = formatModelOptionLabel(getConfiguredVersionLabel());
@@ -644,6 +705,13 @@ function buildModelSelectionExpression(targetModel, strategy) {
       return COMPOSER_SIGNAL_INCLUDES.some((token) => token && signal.includes(token));
     };
     const activeSelectionMatchesTarget = () => {
+      if (targetIsLatest) {
+        const checkedAdvancedRadio = findCheckedAdvancedModelRadio();
+        if (checkedAdvancedRadio) {
+          return isLatestModelLabel(checkedAdvancedRadio.textContent ?? '');
+        }
+        return latestButtonSelected();
+      }
       if (advancedModelSignalMatchesTarget()) {
         return true;
       }
@@ -718,6 +786,11 @@ function buildModelSelectionExpression(targetModel, strategy) {
 
     const scoreOption = (normalizedText, testid, node) => {
       // Assign a score to every node so we can pick the most likely match without brittle equality checks.
+      // Latest is localized in the advanced radio list. Match the documented labels
+      // exactly instead of falling through to generic scoring, which could select Sol.
+      if (targetIsLatest) {
+        return isLatestModelLabel(node?.textContent ?? '') ? 2000 : 0;
+      }
       if (!normalizedText && !testid) {
         return 0;
       }
@@ -1368,6 +1441,10 @@ function buildModelMatchersLiteral(targetModel) {
         testIdTokens.add("gpt5-6");
         testIdTokens.add("gpt56");
     }
+    if (base === "latest") {
+        // ChatGPT's Japanese advanced-model radio is named exactly "最新".
+        push("最新", labelTokens);
+    }
     // Numeric variations (5.5 <-> 55 <-> gpt-5-5)
     if (base.includes("5.5") || base.includes("5-5") || base.includes("55")) {
         push("5.5", labelTokens);

package/dist/src/browser/actions/promptComposer.js

@@ -11,6 +11,7 @@ import { stageAttachmentPrompt } from "./attachmentPrompt.js";
 import { BrowserAutomationError } from "../../oracle/errors.js";
 import { buildAttachmentEvidenceExpression } from "./attachmentEvidence.js";
 import { buildAttachmentProgressExpression } from "./attachmentProgress.js";
+import { activateWebSearch } from "./webSearch.js";
 const ENTER_KEY_EVENT = {
     key: "Enter",
     code: "Enter",
@@ -196,6 +197,8 @@ export async function submitPrompt(deps, prompt, logger) {
             observedLength,
         });
     }
+    if (deps.webSearch)
+        await activateWebSearch(runtime, input, prompt, logger);
     const clicked = await attemptSendButton(runtime, input, logger, deps?.attachmentNames, deps?.attachmentTimeoutMs, deps?.page, deps?.attachmentNavigationUrl);
     if (!clicked) {
         await dispatchEnterKey(input);

package/dist/src/browser/actions/thinkingTime.js

@@ -192,6 +192,10 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const targetLevelLiteral = JSON.stringify(level.toLowerCase());
     const targetModelKindLiteral = JSON.stringify(inferThinkingTargetModelKind(desiredModel));
     const targetIsGpt56ModelLiteral = JSON.stringify(/(?:^|[^0-9])5[._ -]6(?:[^0-9]|$)/i.test(desiredModel ?? ""));
+    // Astra resolves the gpt-6-pro request to this exact model-picker alias. Keep
+    // this deliberately narrow: a generic unknown model must not claim its
+    // version-prefixed effort pill whose ownership we cannot establish.
+    const targetIsAstraLatestLiteral = JSON.stringify((desiredModel ?? "").trim().toLowerCase() === "latest");
     return `(async () => {
     ${buildClickDispatcher()}
 
@@ -201,13 +205,14 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const TARGET_LEVEL = ${targetLevelLiteral};
     const TARGET_MODEL_KIND = ${targetModelKindLiteral};
     const TARGET_IS_GPT56_MODEL = ${targetIsGpt56ModelLiteral};
+    const TARGET_IS_ASTRA_LATEST = ${targetIsAstraLatestLiteral};
 
     // Multilingual matchers: English level token + observed localized variants.
     const LEVEL_TOKENS = {
       light: ['light', 'instant', 'sofort', 'leicht', '最速', '轻', '极速', '즉시'],
       standard: ['standard', 'medium', 'mittel', '中程度', '标准', '中', '중간'],
       extended: ['extended', 'high', 'hoch', 'erweitert', '高い', '扩展', '深度', '加强', '高', '높음'],
-      'extra-high': ['extra high', 'sehr hoch', '非常に高い', '极高', '매우 높음'],
+      'extra-high': ['extra high', 'sehr hoch', '非常に高い', '極高', '极高', '매우 높음'],
       heavy: ['heavy', 'schwer', '重度', '加重'],
     };
     // Pro is a tier you can request, but it is also a MODEL name, so it must never
@@ -216,6 +221,29 @@ function buildThinkingTimeExpression(level, desiredModel) {
     // "Instant"/"Pro" would look like a tier list. Keep it to target matching only.
     const TARGET_LEVEL_TOKENS = { ...LEVEL_TOKENS, pro: ['pro'] };
     const targetTokens = TARGET_LEVEL_TOKENS[TARGET_LEVEL] || [TARGET_LEVEL];
+    const normalizeAstraLabel = (value) =>
+      String(value ?? '')
+        .normalize('NFC')
+        .toLowerCase()
+        .split(String.fromCharCode(9)).join(' ')
+        .split(String.fromCharCode(10)).join(' ')
+        .split(String.fromCharCode(13)).join(' ')
+        .split(String.fromCharCode(12)).join(' ')
+        .split(' ').filter(Boolean).join(' ');
+    const isAstraLatestEffortPill = (label) =>
+      TARGET_IS_ASTRA_LATEST &&
+      Object.values(TARGET_LEVEL_TOKENS).some((tokens) =>
+        tokens.some((token) => {
+          // Do not use the generic matcher here: ownership needs an exact
+          // version prefix plus a known localized tier, not token containment.
+          const tier = normalizeAstraLabel(token);
+          const observed = normalizeAstraLabel(label);
+          return observed === '6 ' + tier || observed === '6' + tier;
+        }),
+      );
+    const isSolModelPillForLatest = (label) =>
+      TARGET_IS_ASTRA_LATEST &&
+      ['5.6 pro', '5.6pro', '5 6 pro'].includes(normalizeAstraLabel(label));
 
     const INITIAL_WAIT_MS = 150;
     const STEP_WAIT_MS = 200;
@@ -1002,11 +1030,12 @@ function buildThinkingTimeExpression(level, desiredModel) {
           .filter(Boolean);
         if (selections.length !== 1) return null;
         const { label, index, level } = selections[0];
-        // This adapter owns the observed five-tier layout only. A different range
-        // or contradictory announcement must not turn a numeric guess into proof.
-        if (thumb.getAttribute('aria-valuemin') !== '0' || thumb.getAttribute('aria-valuemax') !== '4' ||
-            thumb.getAttribute('aria-valuenow') !== String(index)) return null;
-        return { control, label, index, level };
+        // Quota-limited accounts expose four tiers; the fourth remains Extra High.
+        // Require an observed range and matching label/index before trusting either.
+        const maximum = thumb.getAttribute('aria-valuemax');
+        if (thumb.getAttribute('aria-valuemin') !== '0' || !['3', '4'].includes(maximum) ||
+            index > Number(maximum) || thumb.getAttribute('aria-valuenow') !== String(index)) return null;
+        return { control, label, index, level, maximum: Number(maximum) };
       };
       let current = resolve();
       const finish = (result) => { closeOpenMenus(); return result; };
@@ -1026,6 +1055,10 @@ function buildThinkingTimeExpression(level, desiredModel) {
         }
         return finish(failure('option-not-found'));
       }
+      const unavailable = () => finish(failure('option-disabled', {
+        label: 'Pro', notice: 'the available four-tier effort slider does not include Pro',
+      }));
+      if (targetIndex > current.maximum) return unavailable();
       if (current.level === target) return finish({ status: 'already-selected', label: current.label });
       const deadline = performance.now() + MAX_WAIT_MS;
       for (let attempt = 0; attempt < 4 && performance.now() < deadline; attempt += 1) {
@@ -1041,6 +1074,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
           if (next && next.index !== previousIndex) { current = next; break; }
         }
         if (!current) return finish(failure('selection-unverified'));
+        if (targetIndex > current.maximum) return unavailable();
         if (current.level === target) return finish({ status: 'switched', label: current.label });
       }
       return finish(failure('selection-unverified'));
@@ -1062,6 +1096,9 @@ function buildThinkingTimeExpression(level, desiredModel) {
           if (seen.has(button) || !isVisible(button)) continue;
           seen.add(button);
           if (button.getAttribute?.('data-testid') === 'model-switcher-dropdown-button') continue;
+          // A 5.6 Pro model pill is not Astra Latest's 6-prefixed effort owner.
+          // Keep this rejection ahead of the generic compatibility matcher.
+          if (isSolModelPillForLatest(button.textContent ?? '')) continue;
           const label = normalize(
             (button.getAttribute?.('aria-label') ?? '') + ' ' +
             (button.getAttribute?.('data-testid') ?? '') + ' ' +
@@ -1071,6 +1108,11 @@ function buildThinkingTimeExpression(level, desiredModel) {
             (TARGET_MODEL_KIND === 'pro' && hasToken(label, 'pro') && !hasToken(label, 'thinking')) ||
             (TARGET_MODEL_KIND === 'thinking' && hasToken(label, 'thinking') && !hasToken(label, 'pro')) ||
             (!TARGET_MODEL_KIND && hasToken(label, 'thinking')) ||
+            // Astra Latest prefixes a supported effort label with "6" (for
+            // example, "6 Pro" or textContent-concatenated "6Pro"). This is
+            // recognized only for the exact Latest target; selection still
+            // requires the direct slider's leading label and numeric ARIA proof.
+            isAstraLatestEffortPill(button.textContent ?? '') ||
             (button.matches?.('button.__composer-pill') && matchesAnyEffortLevel(label))
           ) {
             return button;
@@ -1157,6 +1199,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
         tokens.some((token) => normalize(token) === pillLabel),
       );
       const pillNamesEffortNotModel =
+        TARGET_IS_ASTRA_LATEST ||
         TARGET_IS_GPT56_MODEL ||
         (pillIsBareEffortTier && Boolean(document.querySelector(INTELLIGENCE_MENU_SELECTOR)));
       const composerModelKind =

package/dist/src/browser/actions/webSearch.js

@@ -0,0 +1,96 @@
+import { BrowserAutomationError } from "../../oracle/errors.js";
+import { INPUT_SELECTORS } from "../constants.js";
+import { delay } from "../utils.js";
+import { activateComposerPlus, captureComposerNavigationUrl, assertComposerPlusStayedInPlace, } from "./attachments.js";
+import { buildComposerNavigationValidationExpression } from "./attachmentContext.js";
+import { buildClickDispatcher } from "./domEvents.js";
+export function matchesWebSearchMenuLabel(value) {
+    return [
+        "search",
+        "searchfindontheweb",
+        "websearch",
+        "websearchfindreal-timenewsandinfo",
+    ].includes(value.replace(/\s+/g, "").toLowerCase());
+}
+export function buildWebSearchVerificationExpression(prompt) {
+    return `(() => {
+    const visible = node => node instanceof HTMLElement && node.getBoundingClientRect().width > 0 && node.getBoundingClientRect().height > 0;
+    const editor = ${JSON.stringify(INPUT_SELECTORS)}.flatMap(selector => Array.from(document.querySelectorAll(selector))).find(visible);
+    if (!editor) return { selected: false, promptMatches: false };
+    const chip = editor.querySelector('[data-inline-selection-pill][data-id="search"][data-system-hint-type="search"]');
+    const copy = editor.cloneNode(true);
+    copy.querySelectorAll('[data-inline-selection-pill], [data-inline-selection-pill-cursor-target]').forEach(node => node.remove());
+    const readText = node => {
+      if (node.nodeType === 3) return node.textContent ?? '';
+      const text = Array.from(node.childNodes).map(readText).join('');
+      return text + (['P', 'DIV', 'BR', 'LI', 'PRE'].includes(node.nodeName) ? '\\n' : '');
+    };
+    const normalize = text => String(text ?? '').replace(/[\\u200b\\ufeff]/g, '').replace(/\\s+/g, ' ').trim();
+    return { selected: Boolean(chip && visible(chip)), promptMatches: normalize(readText(copy)) === normalize(${JSON.stringify(prompt)}) };
+  })()`;
+}
+export function buildWebSearchSelectionExpression(navigationUrl) {
+    return `(() => {
+    ${buildClickDispatcher()}
+    const matchesLabel = ${matchesWebSearchMenuLabel.toString()};
+    const navigation = ${buildComposerNavigationValidationExpression(navigationUrl)};
+    if (!navigation.contextMatches || navigation.workSelected || navigation.modeUnverified) return 'context-changed';
+    const visible = node => node instanceof HTMLElement && node.getBoundingClientRect().width > 0 && node.getBoundingClientRect().height > 0;
+    const roots = Array.from(document.querySelectorAll('main .popover, [data-radix-popper-content-wrapper], [data-floating-ui-portal], [role="menu"], [role="listbox"]')).filter(visible);
+    const candidates = roots.flatMap(root => Array.from(root.querySelectorAll('[data-radix-collection-item], [role="menuitem"], [role="option"], .__menu-item, [class*="menu-item"]')));
+    const match = candidates.find(node => {
+      if (!visible(node) || node.hasAttribute('disabled') || node.getAttribute('aria-disabled') === 'true') return false;
+      return matchesLabel(node.textContent ?? '');
+    });
+    if (!match) return 'missing';
+    dispatchClickSequence(match);
+    return 'clicked';
+  })()`;
+}
+/** Web Search is an inline editor hint, so activate it after staging text/attachments. */
+export async function activateWebSearch(runtime, input, prompt, logger) {
+    const navigationUrl = await captureComposerNavigationUrl(runtime);
+    const verify = async () => {
+        const { result, exceptionDetails } = await runtime.evaluate({
+            expression: buildWebSearchVerificationExpression(prompt),
+            returnByValue: true,
+        });
+        if (exceptionDetails)
+            return false;
+        return result?.value?.selected === true && result?.value?.promptMatches === true;
+    };
+    if (await verify())
+        return;
+    const activated = await activateComposerPlus(runtime, input, navigationUrl);
+    if (activated.method === "unavailable")
+        throw new BrowserAutomationError("Web Search requires the ChatGPT composer tools menu.", {
+            stage: "web-search-activate",
+        });
+    const deadline = Date.now() + 5_000;
+    let clicked = false;
+    while (Date.now() < deadline) {
+        const outcome = await runtime.evaluate({
+            expression: buildWebSearchSelectionExpression(navigationUrl),
+            returnByValue: true,
+        });
+        if (outcome.result?.value === "clicked") {
+            clicked = true;
+            break;
+        }
+        if (outcome.exceptionDetails || outcome.result?.value !== "missing")
+            break;
+        await delay(100);
+    }
+    if (clicked) {
+        const confirmationDeadline = Date.now() + 3_000;
+        do {
+            await assertComposerPlusStayedInPlace(runtime, navigationUrl);
+            if (await verify()) {
+                logger("Web Search selected; inline search hint and staged prompt verified.");
+                return;
+            }
+            await delay(100);
+        } while (Date.now() < confirmationDeadline);
+    }
+    throw new BrowserAutomationError("Web Search selection could not be verified; the prompt was not submitted. This pilot supports the English ChatGPT Web search control.", { stage: "web-search-activate" });
+}

package/dist/src/browser/chromeLifecycle.js

@@ -7,6 +7,7 @@ import { launch, Launcher, } from "chrome-launcher";
 import { cleanupStaleProfileState } from "./profileState.js";
 import { delay } from "./utils.js";
 import { isWsl, resolveWslChromeLaunchRoute } from "./wslHost.js";
+import { BrowserCancellation } from "./cancellation.js";
 export async function launchChrome(config, userDataDir, logger) {
     const { connectHost, debugBindAddress, usePatchedLauncher } = resolveWslChromeLaunchRoute();
     const debugPort = config.debugPort ?? parseDebugPortEnv();
@@ -352,9 +353,10 @@ export async function connectToRemoteChrome(host, port, logger, targetUrl, brows
             return {
                 client: targetConnection.client,
                 targetId: targetConnection.targetId,
-                close: async () => {
+                close: async (closeOptions) => {
                     await targetConnection.client.close().catch(() => undefined);
-                    await closeRemoteChromeTarget(host, port, targetConnection.targetId, logger);
+                    if (!closeOptions?.preserveTarget)
+                        await closeRemoteChromeTarget(host, port, targetConnection.targetId, logger);
                 },
             };
         }
@@ -387,21 +389,31 @@ export async function closeRemoteChromeTarget(host, port, targetId, logger) {
     }
 }
 export async function listRemoteChromeTargets(options) {
-    if (!options.browserWSEndpoint) {
-        const targets = await CDP.List({ host: options.host, port: options.port });
-        return targets;
-    }
-    const browser = await connectToBrowserWebSocket(options.host, options.port, options.browserWSEndpoint, options.logger ?? (() => { }), options.approvalWaitMs);
+    const logger = options.logger ?? (() => { });
+    const cancellation = new BrowserCancellation(options.signal, logger);
     try {
-        const result = await browser.Target.getTargets();
-        return (result.targetInfos ?? []).map((target) => ({
-            targetId: target.targetId,
-            type: target.type,
-            url: target.url,
-        }));
+        return await cancellation.run(async () => {
+            if (!options.browserWSEndpoint) {
+                const targets = await cancellation.call(() => CDP.List({ host: options.host, port: options.port }));
+                return targets;
+            }
+            const browser = await cancellation.acquire(() => connectToBrowserWebSocket(options.host, options.port, options.browserWSEndpoint, logger, options.approvalWaitMs), (lateBrowser) => lateBrowser.close());
+            try {
+                const client = cancellation.client(browser);
+                const result = await client.Target.getTargets();
+                return (result.targetInfos ?? []).map((target) => ({
+                    targetId: target.targetId,
+                    type: target.type,
+                    url: target.url,
+                }));
+            }
+            finally {
+                await browser.close().catch(() => undefined);
+            }
+        });
     }
     finally {
-        await browser.close().catch(() => undefined);
+        cancellation.dispose();
     }
 }
 export async function connectToRemoteChromeTarget(host, port, logger, options) {
@@ -431,9 +443,9 @@ export async function connectToRemoteChromeTarget(host, port, logger, options) {
             client,
             targetId,
             browserWSEndpoint: options.browserWSEndpoint,
-            close: async () => {
+            close: async (closeOptions) => {
                 await browser.Target.detachFromTarget({ sessionId: attached.sessionId }).catch(() => undefined);
-                if (options.closeTargetOnDispose && targetId) {
+                if (options.closeTargetOnDispose && targetId && !closeOptions?.preserveTarget) {
                     await browser.Target.closeTarget({ targetId }).catch(() => undefined);
                 }
                 await browser.close().catch(() => undefined);

package/dist/src/browser/config.js

@@ -123,7 +123,7 @@ export function resolveBrowserConfig(config) {
     };
 }
 function normalizeResearchMode(value) {
-    return value === "deep" ? "deep" : "off";
+    return value === "deep" || value === "search" ? value : "off";
 }
 function normalizeArchiveMode(value) {
     return value === "always" || value === "never" ? value : "auto";