@steipete/oracle 1.0.8 → 1.1.0

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

@@ -0,0 +1,190 @@
+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': {
+            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.');
+        }
+    }
+}
+function buildModelSelectionExpression(targetModel) {
+    const matchers = buildModelMatchersLiteral(targetModel);
+    const labelLiteral = JSON.stringify(matchers.labelTokens);
+    const idLiteral = JSON.stringify(matchers.testIdTokens);
+    const menuContainerLiteral = JSON.stringify(MENU_CONTAINER_SELECTOR);
+    const menuItemLiteral = JSON.stringify(MENU_ITEM_SELECTOR);
+    return `(() => {
+    const BUTTON_SELECTOR = '${MODEL_BUTTON_SELECTOR}';
+    const LABEL_TOKENS = ${labelLiteral};
+    const TEST_IDS = ${idLiteral};
+    const CLICK_INTERVAL_MS = 50;
+    const MAX_WAIT_MS = 12000;
+    const normalizeText = (value) => {
+      if (!value) {
+        return '';
+      }
+      return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, ' ')
+        .replace(/\\s+/g, ' ')
+        .trim();
+    };
+
+    const button = document.querySelector(BUTTON_SELECTOR);
+    if (!button) {
+      return { status: 'button-missing' };
+    }
+
+    let lastPointerClick = 0;
+    const pointerClick = () => {
+      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 findOption = () => {
+      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 testid = (option.getAttribute('data-testid') ?? '').toLowerCase();
+          const text = option.textContent ?? '';
+          const normalizedText = normalizeText(text);
+          const matchesTestId = testid && TEST_IDS.some((id) => testid.includes(id));
+          const matchesText = LABEL_TOKENS.some((token) => {
+            const normalizedToken = normalizeText(token);
+            if (!normalizedToken) {
+              return false;
+            }
+            return normalizedText.includes(normalizedToken);
+          });
+          if (matchesTestId || matchesText) {
+            return option;
+          }
+        }
+      }
+      return null;
+    };
+
+    pointerClick();
+    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 > 300) {
+          pointerClick();
+        }
+      };
+      const attempt = () => {
+        ensureMenuOpen();
+        const option = findOption();
+        if (option) {
+          if (optionIsSelected(option)) {
+            resolve({ status: 'already-selected', label: getOptionLabel(option) });
+            return;
+          }
+          option.click();
+          resolve({ status: 'switched', label: getOptionLabel(option) });
+          return;
+        }
+        if (performance.now() - start > MAX_WAIT_MS) {
+          resolve({ status: 'option-not-found' });
+          return;
+        }
+        if (performance.now() - lastPointerClick > 500) {
+          pointerClick();
+        }
+        setTimeout(attempt, CLICK_INTERVAL_MS);
+      };
+      attempt();
+    });
+  })()`;
+}
+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);
+    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);
+    push(`model-switcher-${hyphenated}`, testIdTokens);
+    push(`model-switcher-${collapsed}`, 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),
+    };
+}

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

@@ -0,0 +1,75 @@
+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);
+    }
+}
+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');
+    }
+    logger('Prompt textarea ready');
+}
+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);
+}

package/dist/oracle/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)');
+}

package/dist/oracle/src/browser/chromeLifecycle.js

@@ -0,0 +1,104 @@
+import { rm } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import CDP from 'chrome-remote-interface';
+import { launch } from 'chrome-launcher';
+const execFileAsync = promisify(execFile);
+export async function launchChrome(config, userDataDir, logger) {
+    const chromeFlags = buildChromeFlags(config.headless);
+    const launcher = await launch({
+        chromePath: config.chromePath ?? undefined,
+        chromeFlags,
+        userDataDir,
+    });
+    const pidLabel = typeof launcher.pid === 'number' ? ` (pid ${launcher.pid})` : '';
+    logger(`Launched Chrome${pidLabel} on port ${launcher.port}`);
+    return launcher;
+}
+export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logger) {
+    const signals = ['SIGINT', 'SIGTERM', 'SIGQUIT'];
+    let handling;
+    const handleSignal = (signal) => {
+        if (handling) {
+            return;
+        }
+        handling = true;
+        logger(`Received ${signal}; terminating Chrome process`);
+        void (async () => {
+            try {
+                await chrome.kill();
+            }
+            catch {
+                // ignore kill failures
+            }
+            if (!keepBrowser) {
+                await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+            }
+        })().finally(() => {
+            const exitCode = signal === 'SIGINT' ? 130 : 1;
+            process.exit(exitCode);
+        });
+    };
+    for (const signal of signals) {
+        process.on(signal, handleSignal);
+    }
+    return () => {
+        for (const signal of signals) {
+            process.removeListener(signal, handleSignal);
+        }
+    };
+}
+export async function hideChromeWindow(chrome, logger) {
+    if (process.platform !== 'darwin') {
+        logger('Window hiding is only supported on macOS');
+        return;
+    }
+    if (!chrome.pid) {
+        logger('Unable to hide window: missing Chrome PID');
+        return;
+    }
+    const script = `tell application "System Events"
+    try
+      set visible of (first process whose unix id is ${chrome.pid}) to false
+    end try
+  end tell`;
+    try {
+        await execFileAsync('osascript', ['-e', script]);
+        logger('Chrome window hidden (Cmd-H)');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Failed to hide Chrome window: ${message}`);
+    }
+}
+export async function connectToChrome(port, logger) {
+    const client = await CDP({ port });
+    logger('Connected to Chrome DevTools protocol');
+    return client;
+}
+function buildChromeFlags(headless) {
+    const flags = [
+        '--disable-background-networking',
+        '--disable-background-timer-throttling',
+        '--disable-breakpad',
+        '--disable-client-side-phishing-detection',
+        '--disable-default-apps',
+        '--disable-hang-monitor',
+        '--disable-popup-blocking',
+        '--disable-prompt-on-repost',
+        '--disable-sync',
+        '--disable-translate',
+        '--metrics-recording-only',
+        '--no-first-run',
+        '--safebrowsing-disable-auto-update',
+        '--disable-features=TranslateUI,AutomationControlled',
+        '--mute-audio',
+        '--window-size=1280,720',
+        '--password-store=basic',
+        '--use-mock-keychain',
+    ];
+    if (headless) {
+        flags.push('--headless=new');
+    }
+    return flags;
+}

package/dist/oracle/src/browser/config.js

@@ -0,0 +1,33 @@
+import { CHATGPT_URL, DEFAULT_MODEL_TARGET } from './constants.js';
+export const DEFAULT_BROWSER_CONFIG = {
+    chromeProfile: null,
+    chromePath: null,
+    url: CHATGPT_URL,
+    timeoutMs: 900_000,
+    inputTimeoutMs: 30_000,
+    cookieSync: true,
+    headless: false,
+    keepBrowser: false,
+    hideWindow: false,
+    desiredModel: DEFAULT_MODEL_TARGET,
+    debug: false,
+    allowCookieErrors: false,
+};
+export function resolveBrowserConfig(config) {
+    return {
+        ...DEFAULT_BROWSER_CONFIG,
+        ...(config ?? {}),
+        url: config?.url ?? DEFAULT_BROWSER_CONFIG.url,
+        timeoutMs: config?.timeoutMs ?? DEFAULT_BROWSER_CONFIG.timeoutMs,
+        inputTimeoutMs: config?.inputTimeoutMs ?? DEFAULT_BROWSER_CONFIG.inputTimeoutMs,
+        cookieSync: config?.cookieSync ?? DEFAULT_BROWSER_CONFIG.cookieSync,
+        headless: config?.headless ?? DEFAULT_BROWSER_CONFIG.headless,
+        keepBrowser: config?.keepBrowser ?? DEFAULT_BROWSER_CONFIG.keepBrowser,
+        hideWindow: config?.hideWindow ?? DEFAULT_BROWSER_CONFIG.hideWindow,
+        desiredModel: config?.desiredModel ?? DEFAULT_BROWSER_CONFIG.desiredModel,
+        chromeProfile: config?.chromeProfile ?? DEFAULT_BROWSER_CONFIG.chromeProfile,
+        chromePath: config?.chromePath ?? DEFAULT_BROWSER_CONFIG.chromePath,
+        debug: config?.debug ?? DEFAULT_BROWSER_CONFIG.debug,
+        allowCookieErrors: config?.allowCookieErrors ?? DEFAULT_BROWSER_CONFIG.allowCookieErrors,
+    };
+}

package/dist/oracle/src/browser/constants.js

@@ -0,0 +1,40 @@
+export const CHATGPT_URL = 'https://chatgpt.com/';
+export const DEFAULT_MODEL_TARGET = 'ChatGPT 5.1';
+export const COOKIE_URLS = ['https://chatgpt.com', 'https://chat.openai.com'];
+export const INPUT_SELECTORS = [
+    'textarea[data-id="prompt-textarea"]',
+    'textarea[placeholder*="Send a message"]',
+    'textarea[aria-label="Message ChatGPT"]',
+    'textarea:not([disabled])',
+    'textarea[name="prompt-textarea"]',
+    '#prompt-textarea',
+    '.ProseMirror',
+    '[contenteditable="true"][data-virtualkeyboard="true"]',
+];
+export const ANSWER_SELECTORS = [
+    'article[data-testid^="conversation-turn"][data-message-author-role="assistant"]',
+    'article[data-testid^="conversation-turn"] [data-message-author-role="assistant"]',
+    'article[data-testid^="conversation-turn"] .markdown',
+    '[data-message-author-role="assistant"] .markdown',
+    '[data-message-author-role="assistant"]',
+];
+export const CONVERSATION_TURN_SELECTOR = 'article[data-testid^="conversation-turn"]';
+export const ASSISTANT_ROLE_SELECTOR = '[data-message-author-role="assistant"]';
+export const CLOUDFLARE_SCRIPT_SELECTOR = 'script[src*="/challenge-platform/"]';
+export const CLOUDFLARE_TITLE = 'just a moment';
+export const PROMPT_PRIMARY_SELECTOR = '#prompt-textarea';
+export const PROMPT_FALLBACK_SELECTOR = 'textarea[name="prompt-textarea"]';
+export const FILE_INPUT_SELECTOR = 'form input[type="file"]:not([accept])';
+export const GENERIC_FILE_INPUT_SELECTOR = 'input[type="file"]:not([accept])';
+export const MENU_CONTAINER_SELECTOR = '[role="menu"], [data-radix-collection-root]';
+export const MENU_ITEM_SELECTOR = 'button, [role="menuitem"], [role="menuitemradio"], [data-testid*="model-switcher-"]';
+export const UPLOAD_STATUS_SELECTORS = [
+    '[data-testid*="upload"]',
+    '[data-testid*="attachment"]',
+    '[data-state="loading"]',
+    '[aria-live="polite"]',
+];
+export const STOP_BUTTON_SELECTOR = '[data-testid="stop-button"]';
+export const SEND_BUTTON_SELECTOR = '[data-testid="send-button"]';
+export const MODEL_BUTTON_SELECTOR = '[data-testid="model-switcher-dropdown-button"]';
+export const COPY_BUTTON_SELECTOR = 'button[data-testid="copy-turn-action-button"]';