@steipete/oracle 0.4.0

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

@@ -0,0 +1,300 @@
+import { MENU_CONTAINER_SELECTOR, MENU_ITEM_SELECTOR, MODEL_BUTTON_SELECTOR, } from '../constants.js';
+import { logDomFailure } from '../domDebug.js';
+export async function ensureModelSelection(Runtime, desiredModel, logger) {
+    const outcome = await Runtime.evaluate({
+        expression: buildModelSelectionExpression(desiredModel),
+        awaitPromise: true,
+        returnByValue: true,
+    });
+    const result = outcome.result?.value;
+    switch (result?.status) {
+        case 'already-selected':
+        case 'switched':
+        case 'switched-best-effort': {
+            const label = result.label ?? desiredModel;
+            logger(`Model picker: ${label}`);
+            return;
+        }
+        case 'option-not-found': {
+            await logDomFailure(Runtime, logger, 'model-switcher-option');
+            throw new Error(`Unable to find model option matching "${desiredModel}" in the model switcher.`);
+        }
+        default: {
+            await logDomFailure(Runtime, logger, 'model-switcher-button');
+            throw new Error('Unable to locate the ChatGPT model selector button.');
+        }
+    }
+}
+/**
+ * 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.
+ */
+function buildModelSelectionExpression(targetModel) {
+    const matchers = buildModelMatchersLiteral(targetModel);
+    const labelLiteral = JSON.stringify(matchers.labelTokens);
+    const idLiteral = JSON.stringify(matchers.testIdTokens);
+    const primaryLabelLiteral = JSON.stringify(targetModel);
+    const menuContainerLiteral = JSON.stringify(MENU_CONTAINER_SELECTOR);
+    const menuItemLiteral = JSON.stringify(MENU_ITEM_SELECTOR);
+    return `(() => {
+    // Capture the selectors and matcher literals up front so the browser expression stays pure.
+    const BUTTON_SELECTOR = '${MODEL_BUTTON_SELECTOR}';
+    const LABEL_TOKENS = ${labelLiteral};
+    const TEST_IDS = ${idLiteral};
+    const PRIMARY_LABEL = ${primaryLabelLiteral};
+    const INITIAL_WAIT_MS = 150;
+    const REOPEN_INTERVAL_MS = 400;
+    const MAX_WAIT_MS = 20000;
+    const normalizeText = (value) => {
+      if (!value) {
+        return '';
+      }
+      return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, ' ')
+        .replace(/\\s+/g, ' ')
+        .trim();
+    };
+    // Normalize every candidate token to keep fuzzy matching deterministic.
+    const normalizedTarget = normalizeText(PRIMARY_LABEL);
+    const normalizedTokens = Array.from(new Set([normalizedTarget, ...LABEL_TOKENS]))
+      .map((token) => normalizeText(token))
+      .filter(Boolean);
+    const targetWords = normalizedTarget.split(' ').filter(Boolean);
+
+    const button = document.querySelector(BUTTON_SELECTOR);
+    if (!button) {
+      return { status: 'button-missing' };
+    }
+
+    let lastPointerClick = 0;
+    const pointerClick = () => {
+      // Some menus ignore synthetic click events.
+      const down = new PointerEvent('pointerdown', { bubbles: true, pointerId: 1, pointerType: 'mouse' });
+      const up = new PointerEvent('pointerup', { bubbles: true, pointerId: 1, pointerType: 'mouse' });
+      const click = new MouseEvent('click', { bubbles: true });
+      button.dispatchEvent(down);
+      button.dispatchEvent(up);
+      button.dispatchEvent(click);
+      lastPointerClick = performance.now();
+    };
+
+    const getOptionLabel = (node) => node?.textContent?.trim() ?? '';
+    const optionIsSelected = (node) => {
+      if (!(node instanceof HTMLElement)) {
+        return false;
+      }
+      const ariaChecked = node.getAttribute('aria-checked');
+      const ariaSelected = node.getAttribute('aria-selected');
+      const ariaCurrent = node.getAttribute('aria-current');
+      const dataSelected = node.getAttribute('data-selected');
+      const dataState = (node.getAttribute('data-state') ?? '').toLowerCase();
+      const selectedStates = ['checked', 'selected', 'on', 'true'];
+      if (ariaChecked === 'true' || ariaSelected === 'true' || ariaCurrent === 'true') {
+        return true;
+      }
+      if (dataSelected === 'true' || selectedStates.includes(dataState)) {
+        return true;
+      }
+      if (node.querySelector('[data-testid*="check"], [role="img"][data-icon="check"], svg[data-icon="check"]')) {
+        return true;
+      }
+      return false;
+    };
+
+    const scoreOption = (normalizedText, testid) => {
+      // Assign a score to every node so we can pick the most likely match without brittle equality checks.
+      if (!normalizedText && !testid) {
+        return 0;
+      }
+      let score = 0;
+      const normalizedTestId = (testid ?? '').toLowerCase();
+      if (normalizedTestId && TEST_IDS.some((id) => normalizedTestId.includes(id))) {
+        score += 1000;
+      }
+      if (normalizedText && normalizedTarget) {
+        if (normalizedText === normalizedTarget) {
+          score += 500;
+        } else if (normalizedText.startsWith(normalizedTarget)) {
+          score += 420;
+        } else if (normalizedText.includes(normalizedTarget)) {
+          score += 380;
+        }
+      }
+      for (const token of normalizedTokens) {
+        // Reward partial matches to the expanded label/token set.
+        if (token && normalizedText.includes(token)) {
+          const tokenWeight = Math.min(120, Math.max(10, token.length * 4));
+          score += tokenWeight;
+        }
+      }
+      if (targetWords.length > 1) {
+        let missing = 0;
+        for (const word of targetWords) {
+          if (!normalizedText.includes(word)) {
+            missing += 1;
+          }
+        }
+        score -= missing * 12;
+      }
+      return Math.max(score, 0);
+    };
+
+    const findBestOption = () => {
+      // Walk through every menu item and keep whichever earns the highest score.
+      let bestMatch = null;
+      const menus = Array.from(document.querySelectorAll(${menuContainerLiteral}));
+      for (const menu of menus) {
+        const buttons = Array.from(menu.querySelectorAll(${menuItemLiteral}));
+        for (const option of buttons) {
+          const text = option.textContent ?? '';
+          const normalizedText = normalizeText(text);
+          const testid = option.getAttribute('data-testid') ?? '';
+          const score = scoreOption(normalizedText, testid);
+          if (score <= 0) {
+            continue;
+          }
+          const label = getOptionLabel(option);
+          if (!bestMatch || score > bestMatch.score) {
+            bestMatch = { node: option, label, score };
+          }
+        }
+      }
+      return bestMatch;
+    };
+
+    return new Promise((resolve) => {
+      const start = performance.now();
+      const ensureMenuOpen = () => {
+        const menuOpen = document.querySelector('[role="menu"], [data-radix-collection-root]');
+        if (!menuOpen && performance.now() - lastPointerClick > REOPEN_INTERVAL_MS) {
+          pointerClick();
+        }
+      };
+
+      // Open once and wait a tick before first scan.
+      pointerClick();
+      const openDelay = () => new Promise((r) => setTimeout(r, INITIAL_WAIT_MS));
+      let initialized = false;
+      const attempt = async () => {
+        if (!initialized) {
+          initialized = true;
+          await openDelay();
+        }
+        ensureMenuOpen();
+        const match = findBestOption();
+        if (match) {
+          if (optionIsSelected(match.node)) {
+            resolve({ status: 'already-selected', label: match.label });
+            return;
+          }
+          match.node.click();
+          resolve({ status: 'switched', label: match.label });
+          return;
+        }
+        if (performance.now() - start > MAX_WAIT_MS) {
+          resolve({ status: 'option-not-found' });
+          return;
+        }
+        setTimeout(attempt, REOPEN_INTERVAL_MS / 2);
+      };
+      attempt();
+    });
+  })()`;
+}
+export function buildModelMatchersLiteralForTest(targetModel) {
+    return buildModelMatchersLiteral(targetModel);
+}
+function buildModelMatchersLiteral(targetModel) {
+    const base = targetModel.trim().toLowerCase();
+    const labelTokens = new Set();
+    const testIdTokens = new Set();
+    const push = (value, set) => {
+        const normalized = value?.trim();
+        if (normalized) {
+            set.add(normalized);
+        }
+    };
+    push(base, labelTokens);
+    push(base.replace(/\s+/g, ' '), labelTokens);
+    const collapsed = base.replace(/\s+/g, '');
+    push(collapsed, labelTokens);
+    const dotless = base.replace(/[.]/g, '');
+    push(dotless, labelTokens);
+    push(`chatgpt ${base}`, labelTokens);
+    push(`chatgpt ${dotless}`, labelTokens);
+    push(`gpt ${base}`, labelTokens);
+    push(`gpt ${dotless}`, labelTokens);
+    // Numeric variations (5.1 ↔ 51 ↔ gpt-5-1)
+    if (base.includes('5.1') || base.includes('5-1') || base.includes('51')) {
+        push('5.1', labelTokens);
+        push('gpt-5.1', labelTokens);
+        push('gpt5.1', labelTokens);
+        push('gpt-5-1', labelTokens);
+        push('gpt5-1', labelTokens);
+        push('gpt51', labelTokens);
+        push('chatgpt 5.1', labelTokens);
+        testIdTokens.add('gpt-5-1');
+        testIdTokens.add('gpt5-1');
+        testIdTokens.add('gpt51');
+    }
+    // Numeric variations (5.0 ↔ 50 ↔ gpt-5-0)
+    if (base.includes('5.0') || base.includes('5-0') || base.includes('50')) {
+        push('5.0', labelTokens);
+        push('gpt-5.0', labelTokens);
+        push('gpt5.0', labelTokens);
+        push('gpt-5-0', labelTokens);
+        push('gpt5-0', labelTokens);
+        push('gpt50', labelTokens);
+        push('chatgpt 5.0', labelTokens);
+        testIdTokens.add('gpt-5-0');
+        testIdTokens.add('gpt5-0');
+        testIdTokens.add('gpt50');
+    }
+    // Pro / research variants
+    if (base.includes('pro')) {
+        push('proresearch', labelTokens);
+        push('research grade', labelTokens);
+        push('advanced reasoning', labelTokens);
+        if (base.includes('5.1') || base.includes('5-1') || base.includes('51')) {
+            testIdTokens.add('gpt-5.1-pro');
+            testIdTokens.add('gpt-5-1-pro');
+            testIdTokens.add('gpt51pro');
+        }
+        if (base.includes('5.0') || base.includes('5-0') || base.includes('50')) {
+            testIdTokens.add('gpt-5.0-pro');
+            testIdTokens.add('gpt-5-0-pro');
+            testIdTokens.add('gpt50pro');
+        }
+        testIdTokens.add('pro');
+        testIdTokens.add('proresearch');
+    }
+    base
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter(Boolean)
+        .forEach((token) => {
+        push(token, labelTokens);
+    });
+    const hyphenated = base.replace(/\s+/g, '-');
+    push(hyphenated, testIdTokens);
+    push(collapsed, testIdTokens);
+    push(dotless, testIdTokens);
+    // data-testid values observed in the ChatGPT picker (e.g., model-switcher-gpt-5.1-pro)
+    push(`model-switcher-${hyphenated}`, testIdTokens);
+    push(`model-switcher-${collapsed}`, testIdTokens);
+    push(`model-switcher-${dotless}`, testIdTokens);
+    if (!labelTokens.size) {
+        labelTokens.add(base);
+    }
+    if (!testIdTokens.size) {
+        testIdTokens.add(base.replace(/\s+/g, '-'));
+    }
+    return {
+        labelTokens: Array.from(labelTokens).filter(Boolean),
+        testIdTokens: Array.from(testIdTokens).filter(Boolean),
+    };
+}
+export function buildModelSelectionExpressionForTest(targetModel) {
+    return buildModelSelectionExpression(targetModel);
+}

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

@@ -0,0 +1,175 @@
+import { CLOUDFLARE_SCRIPT_SELECTOR, CLOUDFLARE_TITLE, INPUT_SELECTORS, } from '../constants.js';
+import { delay } from '../utils.js';
+import { logDomFailure } from '../domDebug.js';
+export async function navigateToChatGPT(Page, Runtime, url, logger) {
+    logger(`Navigating to ${url}`);
+    await Page.navigate({ url });
+    await waitForDocumentReady(Runtime, 45_000);
+}
+export async function ensureNotBlocked(Runtime, headless, logger) {
+    if (await isCloudflareInterstitial(Runtime)) {
+        const message = headless
+            ? 'Cloudflare challenge detected in headless mode. Re-run with --headful so you can solve the challenge.'
+            : 'Cloudflare challenge detected. Complete the “Just a moment…” check in the open browser, then rerun.';
+        logger('Cloudflare anti-bot page detected');
+        throw new Error(message);
+    }
+}
+const LOGIN_CHECK_TIMEOUT_MS = 5_000;
+export async function ensureLoggedIn(Runtime, logger, options = {}) {
+    const outcome = await Runtime.evaluate({
+        expression: buildLoginProbeExpression(LOGIN_CHECK_TIMEOUT_MS),
+        awaitPromise: true,
+        returnByValue: true,
+    });
+    const probe = normalizeLoginProbe(outcome.result?.value);
+    if (probe.ok && !probe.domLoginCta && !probe.onAuthPage) {
+        logger('Login check passed (no login button detected on page)');
+        return;
+    }
+    const domLabel = probe.domLoginCta ? ' Login button detected on page.' : '';
+    const cookieHint = options.remoteSession
+        ? 'The remote Chrome session is not signed into ChatGPT. Sign in there, then rerun.'
+        : (options.appliedCookies ?? 0) === 0
+            ? 'No ChatGPT cookies were applied; sign in to chatgpt.com in Chrome or pass inline cookies (--browser-inline-cookies[(-file)] / ORACLE_BROWSER_COOKIES_JSON).'
+            : 'ChatGPT login appears missing; open chatgpt.com in Chrome to refresh the session or provide inline cookies (--browser-inline-cookies[(-file)] / ORACLE_BROWSER_COOKIES_JSON).';
+    throw new Error(`ChatGPT session not detected.${domLabel} ${cookieHint}`);
+}
+export async function ensurePromptReady(Runtime, timeoutMs, logger) {
+    const ready = await waitForPrompt(Runtime, timeoutMs);
+    if (!ready) {
+        await logDomFailure(Runtime, logger, 'prompt-textarea');
+        throw new Error('Prompt textarea did not appear before timeout');
+    }
+}
+async function waitForDocumentReady(Runtime, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const { result } = await Runtime.evaluate({
+            expression: `document.readyState`,
+            returnByValue: true,
+        });
+        if (result?.value === 'complete' || result?.value === 'interactive') {
+            return;
+        }
+        await delay(100);
+    }
+    throw new Error('Page did not reach ready state in time');
+}
+async function waitForPrompt(Runtime, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const { result } = await Runtime.evaluate({
+            expression: `(() => {
+        const selectors = ${JSON.stringify(INPUT_SELECTORS)};
+        for (const selector of selectors) {
+          const node = document.querySelector(selector);
+          if (node && !node.hasAttribute('disabled')) {
+            return true;
+          }
+        }
+        return false;
+      })()`,
+            returnByValue: true,
+        });
+        if (result?.value) {
+            return true;
+        }
+        await delay(200);
+    }
+    return false;
+}
+async function isCloudflareInterstitial(Runtime) {
+    const { result: titleResult } = await Runtime.evaluate({ expression: 'document.title', returnByValue: true });
+    const title = typeof titleResult.value === 'string' ? titleResult.value : '';
+    const challengeTitle = CLOUDFLARE_TITLE.toLowerCase();
+    if (title.toLowerCase().includes(challengeTitle)) {
+        return true;
+    }
+    const { result } = await Runtime.evaluate({
+        expression: `Boolean(document.querySelector('${CLOUDFLARE_SCRIPT_SELECTOR}'))`,
+        returnByValue: true,
+    });
+    return Boolean(result.value);
+}
+function buildLoginProbeExpression(timeoutMs) {
+    return `(() => {
+    const timer = setTimeout(() => {}, ${timeoutMs});
+    const pageUrl = typeof location === 'object' && location?.href ? location.href : null;
+    const onAuthPage =
+      typeof location === 'object' &&
+      typeof location.pathname === 'string' &&
+      /^\\/(auth|login|signin)/i.test(location.pathname);
+
+    const hasLoginCta = () => {
+      const candidates = Array.from(
+        document.querySelectorAll(
+          [
+            'a[href*="/auth/login"]',
+            'a[href*="/auth/signin"]',
+            'button[type="submit"]',
+            'button[data-testid*="login"]',
+            'button[data-testid*="log-in"]',
+            'button[data-testid*="sign-in"]',
+            'button[data-testid*="signin"]',
+            'button',
+            'a',
+          ].join(','),
+        ),
+      );
+      const textMatches = (text) => {
+        if (!text) return false;
+        const normalized = text.toLowerCase().trim();
+        return ['log in', 'login', 'sign in', 'signin', 'continue with'].some((needle) =>
+          normalized.startsWith(needle),
+        );
+      };
+      for (const node of candidates) {
+        if (!(node instanceof HTMLElement)) continue;
+        const label =
+          node.textContent?.trim() ||
+          node.getAttribute('aria-label') ||
+          node.getAttribute('title') ||
+          '';
+        if (textMatches(label)) {
+          return true;
+        }
+      }
+      return false;
+    };
+
+    const domLoginCta = hasLoginCta();
+    clearTimeout(timer);
+    return {
+      ok: !domLoginCta && !onAuthPage,
+      status: 0,
+      redirected: false,
+      url: pageUrl,
+      pageUrl,
+      domLoginCta,
+      onAuthPage,
+    };
+  })()`;
+}
+function normalizeLoginProbe(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return { ok: false, status: 0 };
+    }
+    const value = raw;
+    const statusRaw = value.status;
+    const status = typeof statusRaw === 'number'
+        ? statusRaw
+        : typeof statusRaw === 'string' && !Number.isNaN(Number(statusRaw))
+            ? Number(statusRaw)
+            : 0;
+    return {
+        ok: Boolean(value.ok),
+        status: Number.isFinite(status) ? status : 0,
+        url: typeof value.url === 'string' ? value.url : null,
+        redirected: Boolean(value.redirected),
+        error: typeof value.error === 'string' ? value.error : null,
+        pageUrl: typeof value.pageUrl === 'string' ? value.pageUrl : null,
+        domLoginCta: Boolean(value.domLoginCta),
+        onAuthPage: Boolean(value.onAuthPage),
+    };
+}

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

@@ -0,0 +1,167 @@
+import { INPUT_SELECTORS, PROMPT_PRIMARY_SELECTOR, PROMPT_FALLBACK_SELECTOR, SEND_BUTTON_SELECTOR, CONVERSATION_TURN_SELECTOR, } from '../constants.js';
+import { delay } from '../utils.js';
+import { logDomFailure } from '../domDebug.js';
+export async function submitPrompt(deps, prompt, logger) {
+    const { runtime, input } = deps;
+    const encodedPrompt = JSON.stringify(prompt);
+    const focusResult = await runtime.evaluate({
+        expression: `(() => {
+      const SELECTORS = ${JSON.stringify(INPUT_SELECTORS)};
+      const dispatchPointer = (target) => {
+        if (!(target instanceof HTMLElement)) {
+          return;
+        }
+        for (const type of ['pointerdown', 'mousedown', 'pointerup', 'mouseup', 'click']) {
+          target.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true, view: window }));
+        }
+      };
+      const focusNode = (node) => {
+        if (!node) {
+          return false;
+        }
+        dispatchPointer(node);
+        if (typeof node.focus === 'function') {
+          node.focus();
+        }
+        const doc = node.ownerDocument;
+        const selection = doc?.getSelection?.();
+        if (selection) {
+          const range = doc.createRange();
+          range.selectNodeContents(node);
+          range.collapse(false);
+          selection.removeAllRanges();
+          selection.addRange(range);
+        }
+        return true;
+      };
+
+      for (const selector of SELECTORS) {
+        const node = document.querySelector(selector);
+        if (!node) continue;
+        if (focusNode(node)) {
+          return { focused: true };
+        }
+      }
+      return { focused: false };
+    })()`,
+        returnByValue: true,
+        awaitPromise: true,
+    });
+    if (!focusResult.result?.value?.focused) {
+        await logDomFailure(runtime, logger, 'focus-textarea');
+        throw new Error('Failed to focus prompt textarea');
+    }
+    await input.insertText({ text: prompt });
+    const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
+    const fallbackSelectorLiteral = JSON.stringify(PROMPT_FALLBACK_SELECTOR);
+    const verification = await runtime.evaluate({
+        expression: `(() => {
+      const editor = document.querySelector(${primarySelectorLiteral});
+      const fallback = document.querySelector(${fallbackSelectorLiteral});
+      return {
+        editorText: editor?.innerText ?? '',
+        fallbackValue: fallback?.value ?? '',
+      };
+    })()`,
+        returnByValue: true,
+    });
+    const editorText = verification.result?.value?.editorText?.trim?.() ?? '';
+    const fallbackValue = verification.result?.value?.fallbackValue?.trim?.() ?? '';
+    if (!editorText && !fallbackValue) {
+        await runtime.evaluate({
+            expression: `(() => {
+        const fallback = document.querySelector(${fallbackSelectorLiteral});
+        if (fallback) {
+          fallback.value = ${encodedPrompt};
+          fallback.dispatchEvent(new InputEvent('input', { bubbles: true, data: ${encodedPrompt}, inputType: 'insertFromPaste' }));
+          fallback.dispatchEvent(new Event('change', { bubbles: true }));
+        }
+        const editor = document.querySelector(${primarySelectorLiteral});
+        if (editor) {
+          editor.textContent = ${encodedPrompt};
+        }
+      })()`,
+        });
+    }
+    const clicked = await attemptSendButton(runtime);
+    if (!clicked) {
+        await input.dispatchKeyEvent({
+            type: 'rawKeyDown',
+            key: 'Enter',
+            code: 'Enter',
+            windowsVirtualKeyCode: 13,
+            nativeVirtualKeyCode: 13,
+        });
+        await input.dispatchKeyEvent({
+            type: 'keyUp',
+            key: 'Enter',
+            code: 'Enter',
+            windowsVirtualKeyCode: 13,
+            nativeVirtualKeyCode: 13,
+        });
+        logger('Submitted prompt via Enter key');
+    }
+    else {
+        logger('Clicked send button');
+    }
+    await verifyPromptCommitted(runtime, prompt, 30_000, logger);
+}
+async function attemptSendButton(Runtime) {
+    const script = `(() => {
+    const button = document.querySelector('${SEND_BUTTON_SELECTOR}');
+    if (!button) {
+      return 'missing';
+    }
+    const ariaDisabled = button.getAttribute('aria-disabled');
+    const disabled = button.hasAttribute('disabled') || ariaDisabled === 'true';
+    if (disabled || window.getComputedStyle(button).display === 'none') {
+      return 'disabled';
+    }
+    button.click();
+    return 'clicked';
+  })()`;
+    const deadline = Date.now() + 2_000;
+    while (Date.now() < deadline) {
+        const { result } = await Runtime.evaluate({ expression: script, returnByValue: true });
+        if (result.value === 'clicked') {
+            return true;
+        }
+        if (result.value === 'missing') {
+            break;
+        }
+        await delay(100);
+    }
+    return false;
+}
+async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger) {
+    const deadline = Date.now() + timeoutMs;
+    const encodedPrompt = JSON.stringify(prompt.trim());
+    const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
+    const fallbackSelectorLiteral = JSON.stringify(PROMPT_FALLBACK_SELECTOR);
+    const script = `(() => {
+    const editor = document.querySelector(${primarySelectorLiteral});
+    const fallback = document.querySelector(${fallbackSelectorLiteral});
+    const normalize = (value) => value?.toLowerCase?.().replace(/\\s+/g, ' ').trim() ?? '';
+    const normalizedPrompt = normalize(${encodedPrompt});
+    const CONVERSATION_SELECTOR = ${JSON.stringify(CONVERSATION_TURN_SELECTOR)};
+    const articles = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+    const userMatched = articles.some((node) => normalize(node?.innerText).includes(normalizedPrompt));
+    return {
+      userMatched,
+      fallbackValue: fallback?.value ?? '',
+      editorValue: editor?.innerText ?? '',
+    };
+  })()`;
+    while (Date.now() < deadline) {
+        const { result } = await Runtime.evaluate({ expression: script, returnByValue: true });
+        const info = result.value;
+        if (info?.userMatched) {
+            return;
+        }
+        await delay(100);
+    }
+    if (logger) {
+        await logDomFailure(Runtime, logger, 'prompt-commit');
+    }
+    throw new Error('Prompt did not appear in conversation before timeout (send may have failed)');
+}