@steipete/oracle 0.10.0 → 0.11.1

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

@@ -13,6 +13,9 @@ export async function ensureModelSelection(Runtime, desiredModel, logger, strate
         case "switched":
         case "switched-best-effort": {
             const label = result.label ?? desiredModel;
+            if (strategy !== "current") {
+                assertResolvedModelSelection(desiredModel, label);
+            }
             logger(`Model picker: ${label}`);
             return;
         }
@@ -22,7 +25,7 @@ export async function ensureModelSelection(Runtime, desiredModel, logger, strate
             const available = (result.hint?.availableOptions ?? []).filter(Boolean);
             const availableHint = available.length > 0 ? ` Available: ${available.join(", ")}.` : "";
             const tempHint = isTemporary && /\bpro\b/i.test(desiredModel)
-                ? ' You are in Temporary Chat mode; Pro models are not available there. Remove "temporary-chat=true" from --chatgpt-url or use a non-Pro model (e.g. gpt-5.2).'
+                ? " You are in Temporary Chat mode; model labels may differ there. If the current Temporary Chat already shows the desired Pro mode, retry with --browser-model-strategy current; otherwise choose an available model or turn Temporary Chat off."
                 : "";
             throw new Error(`Unable to find model option matching "${desiredModel}" in the model switcher.${availableHint}${tempHint}`);
         }
@@ -32,6 +35,29 @@ export async function ensureModelSelection(Runtime, desiredModel, logger, strate
         }
     }
 }
+function assertResolvedModelSelection(desiredModel, resolvedLabel) {
+    const desired = desiredModel.toLowerCase();
+    const resolved = resolvedLabel.toLowerCase();
+    const wantsGpt55Pro = desired === "gpt-5.5-pro" ||
+        desired.includes("5.5 pro") ||
+        desired.includes("5-5 pro") ||
+        (desired.includes("pro") && desired.includes("extended"));
+    if (!wantsGpt55Pro || !resolved) {
+        return;
+    }
+    const hasProSignal = resolved.includes(" pro") ||
+        resolved.endsWith("pro") ||
+        resolved.includes("pro ") ||
+        resolved.includes("extended") ||
+        resolved.includes("gpt-5.5-pro") ||
+        resolved.includes("gpt 5 5 pro");
+    if (!hasProSignal || (resolved.includes("thinking") && !resolved.includes("pro"))) {
+        throw new Error(`Model picker selected "${resolvedLabel}" while "${desiredModel}" requires GPT-5.5 Pro. Use model "gpt-5.5" with browser thinking time for the Thinking variant.`);
+    }
+}
+export function assertResolvedModelSelectionForTest(desiredModel, resolvedLabel) {
+    assertResolvedModelSelection(desiredModel, resolvedLabel);
+}
 /**
  * Builds the DOM expression that runs inside the ChatGPT tab to select a model.
  * The string is evaluated inside Chrome, so keep it self-contained and well-commented.
@@ -91,7 +117,7 @@ function buildModelSelectionExpression(targetModel, strategy) {
           ? '5-1'
           : normalizedTarget.includes('5 0')
             ? '5-0'
-            : null;
+          : null;
     const wantsPro = normalizedTarget.includes(' pro') || normalizedTarget.endsWith(' pro') || normalizedTokens.includes('pro');
     const wantsInstant = normalizedTarget.includes('instant');
     const wantsThinking = normalizedTarget.includes('thinking');
@@ -99,13 +125,21 @@ function buildModelSelectionExpression(targetModel, strategy) {
       if (desiredVersion !== '5-5') return false;
       const label = normalizeText(value);
       if (wantsPro) {
-        return label.includes('pro') && label.includes('extended') && !label.includes('thinking');
+        // ChatGPT UI as of 2026-05: the picker shows just "Pro" (no longer "Pro Extended").
+        // "Extended" is now a thinking-effort sub-setting, not part of the model label.
+        // Accept bare "pro", legacy "pro extended", and reversed "extended pro" (composer pill).
+        return (label === 'pro' || label === 'pro extended' || label === 'extended pro') && !label.includes('thinking');
       }
       if (wantsThinking) {
-        return label.includes('thinking') && label.includes('heavy') && !label.includes('pro');
+        // ChatGPT UI as of 2026-05: the picker shows "Thinking" or "Thinking · Extended"
+        // (normalized to "thinking extended"). Accept both old "thinking heavy" and new labels.
+        return (label === 'thinking' || label === 'thinking extended' || label === 'thinking heavy') && !label.includes('pro');
       }
       return false;
     };
+    const hasProComposerPill = () => Boolean(
+      document.querySelector('button.__composer-pill, button[aria-label="Pro, click to remove"]')
+    );
 
     const button = document.querySelector(BUTTON_SELECTOR);
     if (!button) {
@@ -136,14 +170,29 @@ function buildModelSelectionExpression(targetModel, strategy) {
     const getComposerModelLabel = () =>
       (document.querySelector(COMPOSER_MODEL_SIGNAL_SELECTOR)?.textContent ?? '').trim();
     const readComposerModelSignal = () => normalizeText(getComposerModelLabel());
-    const getResolvedLabel = (fallback) => getComposerModelLabel() || getButtonLabel() || fallback;
+    const withProPillSignal = (label) => {
+      const resolved = label || '';
+      if (!wantsPro || !hasProComposerPill()) return resolved;
+      const normalized = normalizeText(resolved);
+      if (!normalized || normalized.includes('pro')) return resolved;
+      return resolved + ' + Pro';
+    };
+    const getResolvedLabel = (fallback) =>
+      withProPillSignal(getComposerModelLabel() || getButtonLabel() || fallback);
     if (MODEL_STRATEGY === 'current') {
-      return { status: 'already-selected', label: getResolvedLabel(PRIMARY_LABEL) };
+      const currentLabel = getResolvedLabel(PRIMARY_LABEL);
+      return {
+        status: 'already-selected',
+        label: currentLabel,
+      };
     }
     const buttonMatchesTarget = () => {
       const normalizedLabel = normalizeText(getButtonLabel());
       if (!normalizedLabel) return false;
       if (isTargetGpt55VisibleAlias(normalizedLabel)) return true;
+      if (wantsPro && normalizedLabel === 'chatgpt' && hasProComposerPill()) {
+        return true;
+      }
       if (desiredVersion) {
         if (desiredVersion === '5-5' && !normalizedLabel.includes('5 5')) return false;
         if (desiredVersion === '5-4' && !normalizedLabel.includes('5 4')) return false;
@@ -211,6 +260,10 @@ function buildModelSelectionExpression(targetModel, strategy) {
     };
 
     const getOptionLabel = (node) => node?.textContent?.trim() ?? '';
+    const isThinkingEffortControl = (node) =>
+      node instanceof HTMLElement &&
+      (node.getAttribute('data-model-picker-thinking-effort-action') === 'true' ||
+        Boolean(node.closest('[data-model-picker-thinking-effort-action="true"]')));
     const optionIsSelected = (node) => {
       if (!(node instanceof HTMLElement)) {
         return false;
@@ -301,6 +354,19 @@ function buildModelSelectionExpression(targetModel, strategy) {
         }
       }
       const candidateGpt55VisibleAlias = isTargetGpt55VisibleAlias(normalizedText);
+      const candidateHasThinking =
+        normalizedText.includes('thinking') || normalizedTestId.includes('thinking');
+      const candidateHasPro =
+        candidateGpt55VisibleAlias ||
+        normalizedText === 'pro' ||
+        normalizedText.startsWith('pro ') ||
+        normalizedText.includes(' pro ') ||
+        normalizedText.endsWith(' pro') ||
+        normalizedText.includes('proresearch') ||
+        normalizedTestId.includes('pro');
+      if (wantsPro && candidateHasThinking) return 0;
+      if (wantsPro && !candidateHasPro) return 0;
+      if (wantsThinking && candidateHasPro) return 0;
       if (desiredVersion === '5-5' && normalizedText && !candidateGpt55VisibleAlias) {
         const candidateHasVersion =
           normalizedText.includes('5 5') ||
@@ -373,6 +439,9 @@ function buildModelSelectionExpression(targetModel, strategy) {
       for (const menu of menus) {
         const buttons = Array.from(menu.querySelectorAll(${menuItemLiteral}));
         for (const option of buttons) {
+          if (isThinkingEffortControl(option)) {
+            continue;
+          }
           const text = option.textContent ?? '';
           const normalizedText = normalizeText(text);
           const testid = option.getAttribute('data-testid') ?? '';
@@ -391,15 +460,16 @@ function buildModelSelectionExpression(targetModel, strategy) {
     const waitForTargetSelection = (previousButtonLabel, previousComposerSignal) => new Promise((resolve) => {
       const waitStart = performance.now();
       const check = () => {
-        if (
-          activeSelectionMatchesTarget() ||
-          selectionStateChanged(previousButtonLabel, previousComposerSignal)
-        ) {
-          resolve(true);
+        if (activeSelectionMatchesTarget()) {
+          resolve('target');
+          return;
+        }
+        if (selectionStateChanged(previousButtonLabel, previousComposerSignal)) {
+          resolve('changed');
           return;
         }
         if (performance.now() - waitStart > SETTLE_WAIT_MS) {
-          resolve(false);
+          resolve('timeout');
           return;
         }
         setTimeout(check, 100);
@@ -450,7 +520,7 @@ function buildModelSelectionExpression(targetModel, strategy) {
         ensureMenuOpen();
         const match = findBestOption();
         if (match) {
-          if (optionIsSelected(match.node) || activeSelectionMatchesTarget()) {
+          if (activeSelectionMatchesTarget()) {
             closeMenu();
             resolve({ status: 'already-selected', label: getResolvedLabel(match.label) });
             return;
@@ -467,7 +537,7 @@ function buildModelSelectionExpression(targetModel, strategy) {
           }
           // Wait for the selected model signal to settle before reopening the picker.
           waitForTargetSelection(previousButtonLabel, previousComposerSignal).then((selectionSettled) => {
-            if (selectionSettled) {
+            if (selectionSettled === 'target') {
               closeMenu();
               resolve({ status: 'switched', label: getResolvedLabel(match.label) });
               return;
@@ -690,6 +760,6 @@ function buildModelMatchersLiteral(targetModel) {
         testIdTokens: Array.from(testIdTokens).filter(Boolean),
     };
 }
-export function buildModelSelectionExpressionForTest(targetModel) {
-    return buildModelSelectionExpression(targetModel, "select");
+export function buildModelSelectionExpressionForTest(targetModel, strategy = "select") {
+    return buildModelSelectionExpression(targetModel, strategy);
 }

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

@@ -132,6 +132,11 @@ export async function ensureNotBlocked(Runtime, headless, logger) {
         logger("Cloudflare anti-bot page detected");
         throw new BrowserAutomationError(message, { stage: "cloudflare-challenge", headless });
     }
+    if (await isChatGptAccountSecurityBlock(Runtime)) {
+        const message = "ChatGPT account security block detected. Open chatgpt.com in Chrome, secure the account, then rerun Oracle.";
+        logger("ChatGPT account security block detected");
+        throw new BrowserAutomationError(message, { stage: "chatgpt-account-blocked" });
+    }
 }
 const LOGIN_CHECK_TIMEOUT_MS = 5_000;
 export async function ensureLoggedIn(Runtime, logger, options = {}) {
@@ -336,6 +341,23 @@ async function isCloudflareInterstitial(Runtime) {
     });
     return Boolean(result.value);
 }
+async function isChatGptAccountSecurityBlock(Runtime) {
+    try {
+        const outcome = await Runtime.evaluate({
+            expression: `(() => {
+        const text = String(document.body?.innerText || '').toLowerCase().replace(/\\s+/g, ' ');
+        return text.includes('suspicious activity detected') &&
+          text.includes('secure your account') &&
+          text.includes('regain access');
+      })()`,
+            returnByValue: true,
+        });
+        return Boolean(outcome?.result?.value);
+    }
+    catch {
+        return false;
+    }
+}
 function buildLoginProbeExpression(timeoutMs) {
     return `(async () => {
     // Learned: /backend-api/me is the most reliable "am I logged in" signal.