@steipete/oracle 0.15.2 → 0.16.1

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

@@ -404,6 +404,234 @@ function buildThinkingStatusExpression() {
     return null;
   })()`;
 }
+// Present-tense/gerund status labels that mean the model is ACTIVELY working. The
+// past-tense "thought for Xs" summary is deliberately excluded: it persists in the DOM
+// on every completed reasoning turn (and on reattach), so treating its mere presence as
+// "still thinking" would veto completion forever and hang the call. Kept in sync with
+// THINKING_STATUS_LABELS in assistantResponse.ts (the connector phases "searching the
+// web"/"reading"/"finalizing answer" are exactly the GPT-5.5 Pro gaps that produce the
+// preamble->answer window this predicate must cover).
+const ACTIVE_THINKING_LABELS = [
+    "thinking",
+    "pro thinking",
+    "thinking longer for a better answer",
+    "reasoning",
+    "finalizing answer",
+    "finalizing",
+    "analyzing",
+    "researching",
+    "working on it",
+    "working",
+    "planning",
+    "searching the web",
+    "searching",
+    "reading",
+];
+// buildThinkingActivePredicateJs: a SIDE-EFFECT-FREE injected predicate `${fnName}()` that
+// returns true iff the model is ACTIVELY generating/thinking right now. Unlike
+// buildThinkingStatusExpression it never clicks a disclosure and never keys on the mere
+// PRESENCE of a reasoning container ([data-testid*="reasoning"] persists after completion);
+// it keys only on ACTIVITY signals: a visible stop/interrupt control, a visible animated
+// loading-shimmer skeleton, aria-busy, a visible thinking sidecar panel with live progress,
+// or a visible ACTIVE (present-tense) thinking status label. Used as a completion VETO so a
+// settled preamble is never finalized while the reasoning/tool phase is still running.
+function buildThinkingActivityPredicateJs(fnName, detailed) {
+    const stopLiteral = JSON.stringify(STOP_BUTTON_SELECTORS.join(", "));
+    const activeLabelsLiteral = JSON.stringify(ACTIVE_THINKING_LABELS);
+    const conversationLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    const assistantLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
+    const strong = detailed ? "{ active: true, strong: true }" : "true";
+    const weak = detailed ? "{ active: true, strong: false }" : "true";
+    const idle = detailed ? "{ active: false, strong: false }" : "false";
+    return `const ${fnName} = () => {
+    const STOP_SELECTOR = ${stopLiteral};
+    const ACTIVE_LABELS = ${activeLabelsLiteral};
+    const CONVERSATION_SELECTOR = ${conversationLiteral};
+    const ASSISTANT_SELECTOR = ${assistantLiteral};
+    const isVisible = (node) => {
+      if (!(node instanceof HTMLElement)) return false;
+      const rect = node.getBoundingClientRect();
+      if (!rect || rect.width <= 0 || rect.height <= 0) return false;
+      const style = window.getComputedStyle(node);
+      if (
+        style.display === 'none' ||
+        style.visibility === 'hidden' ||
+        (style.opacity !== '' && Number(style.opacity) === 0)
+      ) {
+        return false;
+      }
+      return true;
+    };
+    const some = (selector, pred) => {
+      let nodes;
+      try { nodes = document.querySelectorAll(selector); } catch { return false; }
+      return Array.from(nodes).some((node) => pred(node));
+    };
+    // 1) Stop/interrupt control visible -> generation is active (language-independent).
+    if (some(STOP_SELECTOR, isVisible)) return ${strong};
+    // 2-3) Shimmer/aria-busy are checked only inside the current turn or verified thinking
+    // panel below. Page-global busy UI (history/sidebar/upload) is not model activity.
+    const hasBusyIndicator = (scope) => {
+      let nodes;
+      try {
+        nodes = scope.querySelectorAll(
+          'span.loading-shimmer, .loading-shimmer, [class*="loading-shimmer"], [aria-busy="true"]',
+        );
+      } catch { return false; }
+      return Array.from(nodes).some((node) => isVisible(node));
+    };
+    // 4) Active (present-tense) thinking status label near a status/reasoning node.
+    const norm = (value) =>
+      String(value || '')
+        .normalize('NFD')
+        .replace(/[\\u0300-\\u036f]/g, '')
+        .toLowerCase()
+        .replace(/\\s+/g, ' ')
+        .trim();
+    // Completed reasoning summary: the whole visible label must be a duration summary. Anchoring
+    // prevents an early live trace such as "Thought for 2s: Searching the web" from being
+    // mistaken for completion before the trace grows beyond an arbitrary length threshold.
+    const isCompletedSummary = (text) =>
+      /^(?:(?:reasoning|pro thinking)\\s*)?thought for (?:\\d+(?:\\.\\d+)?\\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours)(?:\\s+\\d+(?:\\.\\d+)?\\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours))*|(?:a|an) [a-z]+(?: [a-z]+){0,2})(?: edit)?$/.test(text);
+    const isActiveLabel = (raw) => {
+      const text = norm(raw);
+      if (!text || text.length > 60) return false;
+      if (isCompletedSummary(text)) return false;
+      return ACTIVE_LABELS.some((label) => text === label || text.startsWith(label + ' '));
+    };
+    const statusNodes = (() => {
+      try {
+        return Array.from(
+          document.querySelectorAll(
+            '[data-testid*="thinking"], [data-testid*="reasoning"]',
+          ),
+        );
+      } catch {
+        return [];
+      }
+    })();
+    for (const node of statusNodes) {
+      if (!(node instanceof HTMLElement) || !isVisible(node)) continue;
+      const testId = norm(node.getAttribute('data-testid'));
+      const verifiedThinkingChrome = testId.includes('thinking') || testId.includes('reasoning');
+      const matches =
+        verifiedThinkingChrome &&
+        (isActiveLabel(node.textContent) || isActiveLabel(node.getAttribute('aria-label')));
+      if (matches) return ${strong};
+    }
+    // 5) A live progress bar (determinate or indeterminate) is active generation, even when no
+    //    label or shimmer is present (some connector/tool phases surface only a progress bar).
+    const hasLiveProgress = (scope) => {
+      let nodes;
+      // Only genuine progress indicators — NOT generic [aria-valuenow] range widgets (sliders,
+      // spinbuttons), which are not liveness signals and would falsely veto completion forever.
+      try {
+        nodes = scope.querySelectorAll('progress, [role="progressbar"]');
+      } catch { return false; }
+      return Array.from(nodes).some((n) => {
+        if (!(n instanceof HTMLElement) || !isVisible(n)) return false;
+        if (n instanceof HTMLProgressElement) {
+          // Determinate <progress> is active only while it has not reached its max.
+          if (Number.isFinite(n.value) && Number.isFinite(n.max) && n.max > 0) return n.value < n.max;
+          return true; // indeterminate
+        }
+        const rawNow = n.getAttribute('aria-valuenow');
+        if (rawNow != null) {
+          const now = Number(rawNow);
+          const rawMax = n.getAttribute('aria-valuemax');
+          const max = rawMax != null && Number.isFinite(Number(rawMax)) ? Number(rawMax) : 100;
+          return Number.isFinite(now) ? now < max : true;
+        }
+        return true; // role=progressbar with no value -> indeterminate -> active
+      });
+    };
+    // Scoped to the CURRENT assistant turn, not the whole document: unrelated page UI can keep
+    // a visible progress bar mounted indefinitely (review P1), and a document-wide veto would
+    // then hold thinkingActive true until the watchdog timeout on a completed response. The
+    // sidecar check below covers verified reasoning panels; here only the latest turn counts.
+    const turns = (() => {
+      try { return document.querySelectorAll(CONVERSATION_SELECTOR); } catch { return []; }
+    })();
+    const lastTurn = turns.length ? turns[turns.length - 1] : null;
+    if (
+      lastTurn instanceof HTMLElement &&
+      (hasBusyIndicator(lastTurn) || hasLiveProgress(lastTurn))
+    ) return ${strong};
+    // 6) A visible thinking/reasoning sidecar panel (the connector/reasoning phase is often
+    //    exposed ONLY through a right-side panel with no inline label). Match the existing
+    //    thinking-monitor heuristic: a right-side panel that looks like thinking, or any such
+    //    container that carries a live progress bar. Presence alone is NOT enough (a collapsed
+    //    reasoning summary persists post-completion); require the thinking cue or live progress.
+    const looksLikeThinking = (node) => {
+      // Judge completion on the panel's VISIBLE text only: data-testid values like
+      // "reasoning-panel" would otherwise taint the completed-summary check, and a live trace
+      // is judged by its full rendered length, not by fragments of it.
+      const visible = norm(node.textContent) || norm(node.getAttribute?.('aria-label'));
+      if (isCompletedSummary(visible)) return false;
+      if (visible.includes('thought for ')) return true;
+      const label = norm([
+        node.textContent,
+        node.getAttribute?.('aria-label'),
+        node.getAttribute?.('data-testid'),
+      ].filter(Boolean).join(' '));
+      return label.includes('thinking') || label.includes('reasoning') || label.includes('pro thinking');
+    };
+    let panels;
+    try {
+      panels = document.querySelectorAll(
+        'aside, [role="complementary"], [role="dialog"], [data-testid*="thinking"], [data-testid*="reasoning"], [class*="sidecar"], [class*="sidebar"]',
+      );
+    } catch { panels = []; }
+    for (const node of Array.from(panels)) {
+      if (!(node instanceof HTMLElement) || !isVisible(node)) continue;
+      const rect = node.getBoundingClientRect();
+      const rightSide = rect.left >= window.innerWidth * 0.35 && rect.width >= 180 && rect.height >= 120;
+      const panelLabel = norm([
+        node.getAttribute?.('aria-label'),
+        node.getAttribute?.('data-testid'),
+        node.className,
+      ].filter(Boolean).join(' '));
+      const verifiedThinkingPanel =
+        panelLabel.includes('thinking') ||
+        panelLabel.includes('reasoning') ||
+        panelLabel.includes('sidecar');
+      if ((hasBusyIndicator(node) || hasLiveProgress(node)) && verifiedThinkingPanel) return ${strong};
+      // A text-only sidecar match is intentionally weak: completed turns can retain a mounted
+      // reasoning panel whose shape/text heuristics still look active. The terminal gate may
+      // override only this weak evidence after a stable, debounced finished-action bar.
+      if (rightSide && looksLikeThinking(node)) return ${weak};
+    }
+    return ${idle};
+  };`;
+}
+export function buildThinkingActivePredicateJs(fnName) {
+    return buildThinkingActivityPredicateJs(fnName, false);
+}
+export function buildThinkingActivityDetailsPredicateJs(fnName) {
+    return buildThinkingActivityPredicateJs(fnName, true);
+}
+export async function readThinkingActivity(Runtime) {
+    try {
+        const { result } = await Runtime.evaluate({
+            expression: `(() => {
+        ${buildThinkingActivityDetailsPredicateJs("readThinkingActivity")}
+        return readThinkingActivity();
+      })()`,
+            returnByValue: true,
+        });
+        const value = result?.value;
+        return { active: Boolean(value?.active), strong: Boolean(value?.strong) };
+    }
+    catch {
+        return { active: false, strong: false };
+    }
+}
+export async function isThinkingActive(Runtime) {
+    return (await readThinkingActivity(Runtime)).active;
+}
 export const startThinkingStatusMonitorForTest = startThinkingStatusMonitor;
 export const readThinkingStatusForTest = readThinkingStatus;
 export const buildThinkingStatusExpressionForTest = buildThinkingStatusExpression;
+export const buildThinkingActivePredicateJsForTest = buildThinkingActivePredicateJs;
+export const buildThinkingActivityDetailsPredicateJsForTest = buildThinkingActivityDetailsPredicateJs;
+export { ACTIVE_THINKING_LABELS };

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

@@ -124,6 +124,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const modelButtonLiteral = JSON.stringify(MODEL_BUTTON_SELECTOR);
     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 ?? ""));
     return `(async () => {
     ${buildClickDispatcher()}
 
@@ -132,13 +133,14 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const MODEL_BUTTON_SELECTOR = ${modelButtonLiteral};
     const TARGET_LEVEL = ${targetLevelLiteral};
     const TARGET_MODEL_KIND = ${targetModelKindLiteral};
+    const TARGET_IS_GPT56_MODEL = ${targetIsGpt56ModelLiteral};
 
     // Bilingual matchers: English level token + observed Chinese variants.
     const LEVEL_TOKENS = {
-      light: ['light', 'instant', '轻'],
-      standard: ['standard', 'medium', '标准'],
-      extended: ['extended', 'high', '扩展', '深度', '加强'],
-      heavy: ['heavy', 'extra high', '重度', '加重', '高'],
+      light: ['light', 'instant', '轻', '极速'],
+      standard: ['standard', 'medium', '标准', '中'],
+      extended: ['extended', 'high', '扩展', '深度', '加强', '高'],
+      heavy: ['heavy', 'extra high', '重度', '加重', '极高'],
     };
     const targetTokens = LEVEL_TOKENS[TARGET_LEVEL] || [TARGET_LEVEL];
 
@@ -166,6 +168,13 @@ function buildThinkingTimeExpression(level, desiredModel) {
         if (!token) return false;
         if (token === 'high') return hasToken(t, 'high') && !hasToken(t, 'extra');
         if (token === 'extra high') return hasToken(t, 'extra') && hasToken(t, 'high');
+        if (token === '极速') {
+          const suffix = t.slice(token.length);
+          return t === token || hasToken(t, token) || /^[0-9]/.test(suffix);
+        }
+        if (['中', '高', '极高'].includes(token)) {
+          return t === token || hasToken(t, token);
+        }
         return t === token || hasToken(t, token) || t.includes(token);
       });
     };
@@ -334,6 +343,9 @@ function buildThinkingTimeExpression(level, desiredModel) {
       if (menu?.getAttribute?.('data-testid') === 'composer-intelligence-picker-content') {
         return true;
       }
+      if (menu?.querySelector?.(INTELLIGENCE_MENU_SELECTOR)) {
+        return true;
+      }
       const label = menu?.querySelector?.('.__menu-label, [class*="menu-label"]');
       return normalize(label?.textContent ?? '').includes('intelligence');
     };
@@ -347,6 +359,21 @@ function buildThinkingTimeExpression(level, desiredModel) {
       const items = Array.from(menu.querySelectorAll(MENU_ITEM_SELECTOR));
       const modelKind = modelKindOverride || effectiveTargetModelKind();
       if (modelKind === 'pro') {
+        // GPT-5.6's unified Intelligence picker exposes Pro as the highest
+        // effort radio directly. It no longer has a nested "Pro Extended"
+        // row, so preserve the legacy request semantics by selecting Pro.
+        if (
+          TARGET_LEVEL === 'extended' &&
+          isIntelligenceEffortMenu(menu) &&
+          !document.querySelector(PRO_EFFORT_TRIGGER_SELECTOR)
+        ) {
+          for (const item of items) {
+            const itemText = normalize(
+              (item.textContent ?? '') + ' ' + (item.getAttribute?.('aria-label') ?? ''),
+            );
+            if (itemText === 'pro') return item;
+          }
+        }
         for (const item of items) {
           const itemText = normalize(
             (item.textContent ?? '') + ' ' + (item.getAttribute?.('aria-label') ?? ''),
@@ -367,7 +394,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
         const itemText = normalize(
           (item.textContent ?? '') + ' ' + (item.getAttribute?.('aria-label') ?? ''),
         );
-        if (modelKind && modelKind !== 'pro' && hasToken(itemText, 'pro')) {
+        if (modelKind !== 'pro' && hasToken(itemText, 'pro')) {
           continue;
         }
         if (
@@ -377,6 +404,16 @@ function buildThinkingTimeExpression(level, desiredModel) {
           return item;
         }
       }
+      if (TARGET_LEVEL === 'heavy') {
+        // Older Chinese layouts used bare 高 for the highest effort. Keep it
+        // only as a second-pass exact fallback so a current 高 row can never
+        // win before the primary 极高 row.
+        for (const item of items) {
+          const itemText = normalize(item.textContent ?? '');
+          const ariaLabel = normalize(item.getAttribute?.('aria-label') ?? '');
+          if (itemText === '高' || ariaLabel === '高') return item;
+        }
+      }
       return null;
     };
     const countEffortLevels = (menu) => {
@@ -390,6 +427,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const isEffortMenu = (menu) => {
       if (!isVisible(menu)) return false;
       if (menu.getAttribute?.('data-testid') === 'composer-intelligence-picker-content') return true;
+      if (menu.querySelector?.(INTELLIGENCE_MENU_SELECTOR)) return true;
       const label = menu.querySelector?.('.__menu-label, [class*="menu-label"]');
       const labelText = normalize(label?.textContent ?? '');
       return (
@@ -450,8 +488,16 @@ function buildThinkingTimeExpression(level, desiredModel) {
       }
       return null;
     };
+    const freshComposerTrigger = (trigger) => {
+      if (!trigger?.matches?.('button.__composer-pill')) return null;
+      // React can replace the composer pill after an effort click. Keep using
+      // the captured node while it is live, but re-query once it is detached so
+      // verification does not read its stale pre-click label.
+      if (trigger.isConnected !== false) return trigger;
+      return findComposerEffortPill() || findModelButton() || trigger;
+    };
     const currentProEffortPillMatchesTarget = (trigger, modelKindOverride = null) => {
-      const button = trigger?.matches?.('button.__composer-pill') ? trigger : findModelButton();
+      const button = freshComposerTrigger(trigger) || findModelButton();
       if ((modelKindOverride || TARGET_MODEL_KIND || modelKindFromNode(button)) !== 'pro') {
         return false;
       }
@@ -466,7 +512,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
     };
     const currentEffortPillMatchesTarget = (trigger, modelKindOverride = null) => {
       if (currentProEffortPillMatchesTarget(trigger, modelKindOverride)) return true;
-      const button = trigger?.matches?.('button.__composer-pill') ? trigger : findModelButton();
+      const button = freshComposerTrigger(trigger) || findModelButton();
       if ((modelKindOverride || TARGET_MODEL_KIND || modelKindFromNode(button)) === 'pro') {
         return false;
       }
@@ -499,8 +545,9 @@ function buildThinkingTimeExpression(level, desiredModel) {
         return { status: 'switched', label };
       }
 
-      if (!refreshed && trigger && trigger.getAttribute?.('aria-expanded') !== 'true') {
-        dispatchClickSequence(trigger);
+      const reopenTrigger = freshComposerTrigger(trigger) || trigger;
+      if (!refreshed && reopenTrigger?.getAttribute?.('aria-expanded') !== 'true') {
+        dispatchClickSequence(reopenTrigger);
         await sleep(INITIAL_WAIT_MS);
       }
       const deadline = performance.now() + 2000;
@@ -556,6 +603,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
     ];
     const findComposerEffortPill = () => {
       const seen = new Set();
+      let gpt56Fallback = null;
       for (const selector of COMPOSER_EFFORT_PILL_SELECTORS) {
         for (const button of document.querySelectorAll(selector)) {
           if (seen.has(button) || !isVisible(button)) continue;
@@ -574,9 +622,16 @@ function buildThinkingTimeExpression(level, desiredModel) {
           ) {
             return button;
           }
+          if (
+            TARGET_IS_GPT56_MODEL &&
+            button.matches?.('button.__composer-pill') &&
+            normalize(button.textContent ?? '') === 'pro'
+          ) {
+            gpt56Fallback ||= button;
+          }
         }
       }
-      return null;
+      return gpt56Fallback;
     };
     let composerEffortPill = findComposerEffortPill();
     let modelBtn = findModelButton();
@@ -634,7 +689,9 @@ function buildThinkingTimeExpression(level, desiredModel) {
     }
     if (composerEffortPill) {
       if (attemptedModelButton && attemptedModelButton !== composerEffortPill) closeOpenMenus();
-      const composerModelKind = TARGET_MODEL_KIND || modelKindFromNode(composerEffortPill);
+      const composerModelKind =
+        TARGET_MODEL_KIND ||
+        (TARGET_IS_GPT56_MODEL ? 'versioned' : modelKindFromNode(composerEffortPill));
       if (composerEffortPill.getAttribute?.('aria-expanded') !== 'true') {
         dispatchClickSequence(composerEffortPill);
         await sleep(INITIAL_WAIT_MS);

package/dist/src/browser/cdpLiveness.js

@@ -0,0 +1,78 @@
+import { listRemoteChromeTargets } from "./chromeLifecycle.js";
+import { verifyDevToolsReachable } from "./profileState.js";
+/**
+ * Probe whether Chrome's DevTools endpoint (and optionally a specific target)
+ * is still reachable after a CDP client WebSocket disconnect.
+ */
+export async function probeChromeTargetLiveness(options) {
+    const host = options.host || "127.0.0.1";
+    const port = options.port;
+    if (!Number.isFinite(port) || port <= 0) {
+        return { endpointReachable: false, targetFound: null, error: "missing debug port" };
+    }
+    const verifyEndpoint = options.verifyEndpoint ?? verifyDevToolsReachable;
+    const endpoint = await verifyEndpoint({ host, port, attempts: 2, timeoutMs: 1500 });
+    if (!endpoint.ok) {
+        return {
+            endpointReachable: false,
+            targetFound: null,
+            error: endpoint.error,
+        };
+    }
+    const targetId = options.targetId?.trim();
+    if (!targetId) {
+        return { endpointReachable: true, targetFound: null };
+    }
+    try {
+        const listTargets = options.listTargets ?? listRemoteChromeTargets;
+        const targets = await listTargets({
+            host,
+            port,
+            browserWSEndpoint: options.browserWSEndpoint,
+        });
+        const match = targets.find((target) => {
+            const id = target.targetId ?? target.id;
+            return id === targetId;
+        });
+        if (!match) {
+            return { endpointReachable: true, targetFound: false };
+        }
+        return {
+            endpointReachable: true,
+            targetFound: true,
+            matchedUrl: typeof match.url === "string" ? match.url : undefined,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        // Endpoint answered /json/version; treat list failures as still recoverable.
+        return { endpointReachable: true, targetFound: null, error: message };
+    }
+}
+export function isRecoverableChromeDisconnect(liveness) {
+    if (!liveness.endpointReachable) {
+        return false;
+    }
+    // Confirmed live target → recoverable.
+    if (liveness.targetFound === true) {
+        return true;
+    }
+    // Confirmed missing target → not recoverable.
+    if (liveness.targetFound === false) {
+        return false;
+    }
+    // targetFound === null:
+    // - no target id was provided (endpoint-only check) → recoverable
+    // - target list failed after a specific id was requested (error set) → fail closed
+    return !liveness.error;
+}
+export function connectionLostUserMessage(options) {
+    if (options.recoverable) {
+        return options.remote
+            ? "Remote Chrome DevTools client disconnected before oracle finished; the browser target appears still alive."
+            : "Chrome DevTools client disconnected before oracle finished; the browser target appears still alive.";
+    }
+    return options.remote
+        ? "Remote Chrome connection lost before Oracle finished."
+        : "Chrome window closed before oracle finished. Please keep it open until completion.";
+}