@steipete/oracle 0.14.1 → 0.15.1

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

@@ -1,15 +1,38 @@
 import { COMPOSER_MODEL_SIGNAL_SELECTOR, MENU_CONTAINER_SELECTOR, MENU_ITEM_SELECTOR, MODEL_BUTTON_SELECTOR, } from "../constants.js";
 import { logDomFailure } from "../domDebug.js";
 import { buildClickDispatcher } from "./domEvents.js";
+import { delay } from "../utils.js";
 const LEGACY_PRO_VERSION_WORD_TOKENS = ["5 4", "5 2", "5 1", "5 0", "gpt 5 pro"];
 const LEGACY_PRO_VERSION_COMPACT_TOKENS = ["gpt54", "gpt52", "gpt51", "gpt50"];
-export async function ensureModelSelection(Runtime, desiredModel, logger, strategy = "select") {
-    const outcome = await Runtime.evaluate({
-        expression: buildModelSelectionExpression(desiredModel, strategy),
-        awaitPromise: true,
-        returnByValue: true,
-    });
-    const result = outcome.result?.value;
+// The model/effort picker is a composer pill that React mounts a beat after the page
+// becomes interactive (~1-4s on a cold profile, e.g. cookie-sync's throwaway Chrome).
+// Re-evaluate while it is still missing, up to a bounded deadline, so selection does not
+// give up before the pill renders. Only "button-missing" waits; a genuine
+// "option-not-found" surfaces immediately.
+const MODEL_BUTTON_WAIT_MS = 8000;
+const MODEL_BUTTON_POLL_MS = 250;
+export async function ensureModelSelection(Runtime, desiredModel, logger, strategy = "select", options = {}) {
+    const buttonWaitMs = options.buttonWaitMs ?? MODEL_BUTTON_WAIT_MS;
+    const buttonPollMs = options.buttonPollMs ?? MODEL_BUTTON_POLL_MS;
+    const deadline = Date.now() + Math.max(0, buttonWaitMs);
+    let result;
+    let announcedWait = false;
+    for (;;) {
+        const outcome = await Runtime.evaluate({
+            expression: buildModelSelectionExpression(desiredModel, strategy),
+            awaitPromise: true,
+            returnByValue: true,
+        });
+        result = outcome.result?.value;
+        if (result?.status !== "button-missing" || Date.now() >= deadline) {
+            break;
+        }
+        if (!announcedWait) {
+            announcedWait = true;
+            logger(`Model picker button not mounted yet; waiting up to ${Math.round(buttonWaitMs / 1000)}s for the composer pill to render.`);
+        }
+        await delay(buttonPollMs);
+    }
     switch (result?.status) {
         case "already-selected":
         case "switched": {
@@ -659,10 +682,27 @@ function buildModelSelectionExpression(targetModel, strategy) {
         normalizedTestId.includes('pro');
       const candidateHasInstant =
         normalizedText.includes('instant') || normalizedTestId.includes('instant');
+      const candidateSelectsConfiguredVersion =
+        Boolean(getConfigurationDialog()) &&
+        candidateSelectsDesiredVersion &&
+        (node?.getAttribute?.('role') === 'option' ||
+          node?.getAttribute?.('role') === 'menuitemradio');
+      const candidateOpensInstantSubmenu =
+        wantsInstant &&
+        candidateSelectsDesiredVersion &&
+        !candidateHasInstant &&
+        (normalizedTestId.includes('submenu') ||
+          node?.getAttribute?.('aria-haspopup') === 'menu' ||
+          node?.getAttribute?.('data-has-submenu') !== null);
       if (wantsPro && candidateHasThinking) return 0;
       if (wantsPro && candidateHasLegacyProVersion && !candidateSelectsDesiredVersion) return 0;
       if (wantsPro && !candidateHasPro && !candidateSelectsDesiredVersion) return 0;
-      if (wantsInstant && !candidateHasInstant && !candidateSelectsDesiredVersion) return 0;
+      if (
+        wantsInstant &&
+        !candidateHasInstant &&
+        !candidateOpensInstantSubmenu &&
+        !candidateSelectsConfiguredVersion
+      ) return 0;
       if (wantsThinking && candidateHasPro) return 0;
       if (wantsThinking && !candidateHasThinking && !candidateSelectsDesiredVersion) return 0;
       if (desiredVersion === '5-5' && normalizedText && !candidateGpt55VisibleAlias) {
@@ -701,10 +741,14 @@ function buildModelSelectionExpression(targetModel, strategy) {
       if (
         desiredVersion &&
         candidateTextVersion === desiredVersion &&
+        !candidateOpensInstantSubmenu &&
         !(wantsThinking && desiredVersion === '5-5' && normalizedText === 'gpt 5 5')
       ) {
         score += 1200;
       }
+      if (candidateOpensInstantSubmenu) {
+        score += 300;
+      }
       if (candidateOpensVersionSubmenu) {
         score += 500;
       }
@@ -809,6 +853,9 @@ function buildModelSelectionExpression(targetModel, strategy) {
       const currentButtonLabel = normalizeText(getButtonLabel());
       return !labelHasProWord(currentButtonLabel) && !hasProComposerPill();
     };
+    const openedSubmenuKeys = new Set();
+    const submenuKey = (normalizedText, testid) =>
+      normalizeText(testid ?? '') + '|' + normalizedText;
 
     const findBestOption = () => {
       // Walk through every menu item and keep whichever earns the highest score.
@@ -823,6 +870,10 @@ function buildModelSelectionExpression(targetModel, strategy) {
           const text = option.textContent ?? '';
           const normalizedText = normalizeText(text);
           const testid = option.getAttribute('data-testid') ?? '';
+          const optionSubmenuKey = submenuKey(normalizedText, testid);
+          if (isSubmenuOption(option, testid) && openedSubmenuKeys.has(optionSubmenuKey)) {
+            continue;
+          }
           let score = scoreOption(normalizedText, testid, option);
           if (score <= 0) {
             continue;
@@ -832,7 +883,14 @@ function buildModelSelectionExpression(targetModel, strategy) {
           }
           const label = getOptionLabel(option);
           if (!bestMatch || score > bestMatch.score) {
-            bestMatch = { node: option, label, score, testid, normalizedText };
+            bestMatch = {
+              node: option,
+              label,
+              score,
+              testid,
+              normalizedText,
+              submenuKey: optionSubmenuKey,
+            };
           }
         }
       }
@@ -924,6 +982,13 @@ function buildModelSelectionExpression(targetModel, strategy) {
       const openDelay = () => new Promise((r) => setTimeout(r, INITIAL_WAIT_MS));
       let initialized = false;
       const attempt = async () => {
+        if (performance.now() - start > MAX_WAIT_MS) {
+          resolve({
+            status: 'option-not-found',
+            hint: { temporaryChat: detectTemporaryChat(), availableOptions: collectAvailableOptions() },
+          });
+          return;
+        }
         if (!initialized) {
           initialized = true;
           await openDelay();
@@ -946,6 +1011,7 @@ function buildModelSelectionExpression(targetModel, strategy) {
           // Keep scanning once the submenu opens instead of treating the submenu click as a final switch.
           const isSubmenu = isSubmenuOption(match.node, match.testid);
           if (isSubmenu) {
+            openedSubmenuKeys.add(match.submenuKey);
             openSubmenuOption(match.node);
             setTimeout(attempt, REOPEN_INTERVAL_MS / 2);
             return;

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

@@ -166,7 +166,7 @@ export async function submitPrompt(deps, prompt, logger) {
             observedLength,
         });
     }
-    const clicked = await attemptSendButton(runtime, logger, deps?.attachmentNames, deps?.attachmentTimeoutMs);
+    const clicked = await attemptSendButton(runtime, input, logger, deps?.attachmentNames, deps?.attachmentTimeoutMs);
     if (!clicked) {
         await input.dispatchKeyEvent({
             type: "keyDown",
@@ -575,7 +575,7 @@ function buildAttachmentReadyExpression(attachmentNames) {
 export function buildAttachmentReadyExpressionForTest(attachmentNames) {
     return buildAttachmentReadyExpression(attachmentNames);
 }
-async function attemptSendButton(Runtime, _logger, attachmentNames, attachmentTimeoutMs) {
+async function attemptSendButton(Runtime, Input, _logger, attachmentNames, attachmentTimeoutMs) {
     const needAttachment = Array.isArray(attachmentNames) && attachmentNames.length > 0;
     const script = `(() => {
     ${buildClickDispatcher()}
@@ -604,10 +604,15 @@ async function attemptSendButton(Runtime, _logger, attachmentNames, attachmentTi
       candidates.push(...Array.from(document.querySelectorAll(selector)));
     }
     const button = candidates.find((node) => isVisible(node) && isEnabled(node)) || null;
-    if (!button) return 'missing';
-    // Use unified pointer/mouse sequence to satisfy React handlers.
+    if (!button) return { status: 'missing' };
+    button.scrollIntoView({ block: 'center', inline: 'center' });
+    const rect = button.getBoundingClientRect();
+    if (rect.width > 0 && rect.height > 0) {
+      return { status: 'point', x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
+    }
+    // Last-resort fallback for unusual DOMs where the button is visible but has no useful rect.
     dispatchClickSequence(button);
-    return 'clicked';
+    return { status: 'clicked' };
   })()`;
     // Give attachment-bearing submissions more headroom. ChatGPT's chip render can
     // settle slowly for multi-file uploads, but plain text sends should keep the
@@ -626,10 +631,19 @@ async function attemptSendButton(Runtime, _logger, attachmentNames, attachmentTi
             }
         }
         const { result } = await Runtime.evaluate({ expression: script, returnByValue: true });
-        if (result.value === "clicked") {
+        const value = result.value;
+        const status = typeof value === "string" ? value : value?.status;
+        if (status === "point" &&
+            typeof value === "object" &&
+            typeof value.x === "number" &&
+            typeof value.y === "number") {
+            await clickTrustedPoint(Runtime, Input, value.x, value.y);
+            return true;
+        }
+        if (status === "clicked") {
             return true;
         }
-        if (result.value === "missing") {
+        if (status === "missing") {
             break;
         }
         await delay(100);
@@ -644,6 +658,23 @@ async function attemptSendButton(Runtime, _logger, attachmentNames, attachmentTi
     }
     return false;
 }
+async function clickTrustedPoint(Runtime, Input, x, y) {
+    if (Input && typeof Input.dispatchMouseEvent === "function") {
+        await Input.dispatchMouseEvent({ type: "mouseMoved", x, y });
+        await Input.dispatchMouseEvent({ type: "mousePressed", x, y, button: "left", clickCount: 1 });
+        await Input.dispatchMouseEvent({ type: "mouseReleased", x, y, button: "left", clickCount: 1 });
+        return;
+    }
+    await Runtime.evaluate({
+        expression: `(() => {
+      const el = document.elementFromPoint(${JSON.stringify(x)}, ${JSON.stringify(y)});
+      if (!(el instanceof HTMLElement)) return false;
+      el.click();
+      return true;
+    })()`,
+        returnByValue: true,
+    });
+}
 function sendButtonTimeoutMs(attachmentNames, attachmentTimeoutMs) {
     if (!Array.isArray(attachmentNames) || attachmentNames.length === 0) {
         return 20_000;
@@ -755,9 +786,13 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
       turnsCount: normalizedTurns.length,
     };
   })()`;
+    let lastProbe;
     while (Date.now() < deadline) {
         const { result } = await Runtime.evaluate({ expression: script, returnByValue: true });
         const info = result.value;
+        if (info && typeof info === "object") {
+            lastProbe = info;
+        }
         const turnsCount = result.value?.turnsCount;
         const matchesPrompt = Boolean(info?.lastMatched || info?.userMatched || info?.prefixMatched);
         const baselineUnknown = typeof info?.baseline === "number" ? info.baseline < 0 : baselineLiteral < 0;
@@ -772,13 +807,12 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
         }
         await delay(100);
     }
+    const finalProbe = await Runtime.evaluate({ expression: script, returnByValue: true })
+        .then((res) => res?.result?.value)
+        .catch(() => undefined);
+    const probe = finalProbe && typeof finalProbe === "object" ? finalProbe : lastProbe;
     if (logger) {
-        logger(`Prompt commit check failed; latest state: ${await Runtime.evaluate({
-            expression: script,
-            returnByValue: true,
-        })
-            .then((res) => JSON.stringify(res?.result?.value))
-            .catch(() => "unavailable")}`);
+        logger(`Prompt commit check failed; latest state: ${probe ? JSON.stringify(probe) : "unavailable"}`);
         await logDomFailure(Runtime, logger, "prompt-commit");
     }
     if (prompt.trim().length >= 50_000) {
@@ -789,7 +823,30 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
             timeoutMs,
         });
     }
-    throw new Error("Prompt did not appear in conversation before timeout (send may have failed)");
+    throw new BrowserAutomationError("Prompt did not appear in conversation before timeout (send may have failed)", {
+        stage: "submit-prompt",
+        code: "prompt-commit-timeout",
+        promptLength: prompt.trim().length,
+        timeoutMs,
+        commitProbe: probe ? summarizeCommitProbe(probe) : undefined,
+    });
+}
+// Keep booleans/counts but replace free text with lengths so session metadata stays lean.
+function summarizeCommitProbe(probe) {
+    return {
+        baseline: probe.baseline,
+        turnsCount: probe.turnsCount,
+        userMatched: probe.userMatched,
+        prefixMatched: probe.prefixMatched,
+        lastMatched: probe.lastMatched,
+        hasNewTurn: probe.hasNewTurn,
+        stopVisible: probe.stopVisible,
+        assistantVisible: probe.assistantVisible,
+        composerCleared: probe.composerCleared,
+        inConversation: probe.inConversation,
+        editorLength: typeof probe.editorValue === "string" ? probe.editorValue.length : undefined,
+        lastTurnLength: typeof probe.lastTurn === "string" ? probe.lastTurn.length : undefined,
+    };
 }
 // biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
 export const __test__ = {

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

@@ -1,5 +1,5 @@
 import { formatElapsed } from "../../oracle/format.js";
-import { ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR } from "../constants.js";
+import { ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR, STOP_BUTTON_SELECTORS, } from "../constants.js";
 const THINKING_STALE_HINT_MS = 10 * 60_000;
 export function startThinkingStatusMonitor(Runtime, logger, options = {}) {
     const intervalMs = resolveThinkingStatusInterval(options.intervalMs);
@@ -127,6 +127,7 @@ async function readThinkingStatus(Runtime) {
 }
 const SAFE_THINKING_STATUS_MESSAGES = new Set([
     "active",
+    "response streaming",
     "thinking sidecar active",
     "thinking sidecar opened",
 ]);
@@ -157,13 +158,16 @@ function buildThinkingStatusExpression() {
         '[aria-live="polite"]',
     ];
     const keywords = ["pro thinking", "thinking", "reasoning"];
+    const stopSelector = STOP_BUTTON_SELECTORS.join(", ");
     const selectorLiteral = JSON.stringify(selectors);
     const keywordsLiteral = JSON.stringify(keywords);
+    const stopSelectorLiteral = JSON.stringify(stopSelector);
     return `(async () => {
     const CONVERSATION_SELECTOR = ${conversationLiteral};
     const ASSISTANT_SELECTOR = ${assistantLiteral};
     const selectors = ${selectorLiteral};
     const keywords = ${keywordsLiteral};
+    const stopSelector = ${stopSelectorLiteral};
     const normalize = (value) =>
       String(value || '')
         .normalize('NFD')
@@ -383,6 +387,20 @@ function buildThinkingStatusExpression() {
         };
       }
     }
+    // Last-resort liveness fallback: selector drift can hide every thinking
+    // indicator while a response is still generating, and returning null here
+    // reads as "dead" downstream. The stop/interrupt control is a stable,
+    // language-independent signal that generation is active; it lives in the
+    // composer, so isComposerAdjacent must not filter it.
+    const stopVisible = Array.from(document.querySelectorAll(stopSelector)).some((node) =>
+      isVisible(node),
+    );
+    if (stopVisible) {
+      return {
+        message: 'response streaming',
+        source: 'inline',
+      };
+    }
     return null;
   })()`;
 }

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

@@ -578,9 +578,62 @@ function buildThinkingTimeExpression(level, desiredModel) {
       }
       return null;
     };
-
-    const composerEffortPill = findComposerEffortPill();
+    let composerEffortPill = findComposerEffortPill();
+    let modelBtn = findModelButton();
+    const modelKindFromLegacyTrailing = (trailing) => {
+      const row = trailing.closest?.(
+        '[role="menuitem"], [role="menuitemradio"], [data-radix-collection-item]',
+      );
+      const idText = normalize(
+        (row?.getAttribute?.('data-testid') ?? '') + ' ' +
+        (trailing.getAttribute?.('data-testid') ?? '')
+      );
+      if (!idText.includes('model switcher')) return null;
+      const modelPart = normalize(idText.replace(/\\bthinking effort\\b.*$/, ''));
+      if (hasToken(modelPart, 'pro')) return 'pro';
+      if (hasToken(modelPart, 'thinking')) return 'thinking';
+      if (hasToken(modelPart, 'instant')) return 'instant';
+      return null;
+    };
+    const legacyEffortOwnerIsReady = () => {
+      if (
+        TARGET_MODEL_KIND === 'pro' &&
+        TARGET_LEVEL === 'extended' &&
+        isVisible(document.querySelector(INTELLIGENCE_MENU_SELECTOR))
+      ) {
+        return true;
+      }
+      const expectedKind = TARGET_MODEL_KIND || modelKindFromNode(modelBtn);
+      return Boolean(
+        expectedKind &&
+        findTrailingButtons().some(
+          (button) => isVisible(button) && modelKindFromLegacyTrailing(button) === expectedKind,
+        ),
+      );
+    };
+    let attemptedModelButton =
+      modelBtn?.getAttribute?.('aria-expanded') === 'true' ? modelBtn : null;
+    const effortOwnerDeadline = performance.now() + MAX_WAIT_MS;
+    while (!composerEffortPill && performance.now() < effortOwnerDeadline) {
+      if (
+        modelBtn &&
+        attemptedModelButton !== modelBtn &&
+        modelBtn.getAttribute?.('aria-expanded') !== 'true'
+      ) {
+        dispatchClickSequence(modelBtn);
+        attemptedModelButton = modelBtn;
+        await sleep(INITIAL_WAIT_MS);
+      }
+      if (modelBtn && legacyEffortOwnerIsReady()) break;
+      await sleep(100);
+      composerEffortPill = findComposerEffortPill();
+      modelBtn = findModelButton();
+      if (modelBtn?.getAttribute?.('aria-expanded') === 'true') {
+        attemptedModelButton = modelBtn;
+      }
+    }
     if (composerEffortPill) {
+      if (attemptedModelButton && attemptedModelButton !== composerEffortPill) closeOpenMenus();
       const composerModelKind = TARGET_MODEL_KIND || modelKindFromNode(composerEffortPill);
       if (composerEffortPill.getAttribute?.('aria-expanded') !== 'true') {
         dispatchClickSequence(composerEffortPill);
@@ -646,22 +699,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
         (trailing.getAttribute?.('data-testid') ?? '')
       );
     };
-    const testIdTextForTrailing = (trailing) => {
-      const row = rowForTrailing(trailing) || findEffortRow(trailing);
-      return normalize(
-        (row?.getAttribute?.('data-testid') ?? '') + ' ' +
-        (trailing.getAttribute?.('data-testid') ?? '')
-      );
-    };
-    const modelKindFromTrailing = (trailing) => {
-      const idText = testIdTextForTrailing(trailing);
-      if (!idText.includes('model switcher')) return null;
-      const modelPart = normalize(idText.replace(/\\bthinking effort\\b.*$/, ''));
-      if (hasToken(modelPart, 'pro')) return 'pro';
-      if (hasToken(modelPart, 'thinking')) return 'thinking';
-      if (hasToken(modelPart, 'instant')) return 'instant';
-      return null;
-    };
+    const modelKindFromTrailing = modelKindFromLegacyTrailing;
     const trailingMatchesTargetModelKind = (trailing) => {
       if (!TARGET_MODEL_KIND) return false;
       const idKind = modelKindFromTrailing(trailing);
@@ -698,12 +736,19 @@ function buildThinkingTimeExpression(level, desiredModel) {
       return null;
     };
 
-    const modelBtn = findModelButton();
+    const modelButtonDeadline = performance.now() + MAX_WAIT_MS;
+    while (!modelBtn && performance.now() < modelButtonDeadline) {
+      await sleep(100);
+      modelBtn = findModelButton();
+    }
     if (!modelBtn) {
       return failure('chip-not-found');
     }
     // Open model menu (idempotent — leaves it open if already open).
-    if (modelBtn.getAttribute('aria-expanded') !== 'true') {
+    if (
+      modelBtn.getAttribute('aria-expanded') !== 'true' &&
+      !legacyEffortOwnerIsReady()
+    ) {
       dispatchClickSequence(modelBtn);
       await sleep(INITIAL_WAIT_MS);
     }