surf-cli 2.16.1 → 2.18.0

package/native/chatgpt-client-ui.cjs

@@ -1,6 +1,7 @@
 const { abortableDelay, throwIfAborted } = require("./abort.cjs");
 const {
   CHATGPT_EFFORT_CHOICES,
+  CHATGPT_EFFORT_VALUE,
   boundedOptionLabels,
   normalizeChatGPTEffortChoice,
   normalizeChatGPTModelChoice,
@@ -29,6 +30,8 @@ const SELECTORS = {
   effortMenuItem: 'button, [role="menuitem"], [role="menuitemradio"]',
   effortMenuLabel: '.__menu-label, [class*="menu-label"]',
   effortSubmenuTrigger: '[role="menuitem"][aria-haspopup="menu"], button[aria-haspopup="menu"]',
+  toolsButton:
+    'button[data-testid="composer-plus-btn"], button[aria-label="Add files and more"]',
   selectedMenuIndicator:
     '[aria-checked="true"], [aria-selected="true"], [data-selected="true"], [data-state="checked"], [data-state="selected"], [data-state="on"]',
   assistantMessage:
@@ -170,257 +173,679 @@ async function waitForPromptReady(cdp, timeoutMs = 30000, signal) {
   return false;
 }
 
-function verificationError(kind, requested, items = [], invalid = false) {
-  const safeRequested = String(requested || "").replace(/\s+/g, " ").trim().slice(0, 80);
-  const available = boundedOptionLabels(items);
-  const accepted = kind === "effort" ? ` Accepted: ${CHATGPT_EFFORT_CHOICES.join(", ")}.` : "";
-  const availableMessage = available.length > 0 ? ` Available: ${available.join(", ")}.` : "";
-  const error = new Error(
-    invalid
-      ? `Invalid ChatGPT effort "${safeRequested}".${accepted}`
-      : `ChatGPT ${kind} verification failed for "${safeRequested}".${accepted}${availableMessage}`,
-  );
-  error.code = "model_verification_failed";
+function uiError(code, message) {
+  const error = new Error(message);
+  error.code = code;
   return error;
 }
 
-async function readPicker(cdp, kind, click = false) {
-  const selector = kind === "model" ? SELECTORS.modelButton : SELECTORS.effortButton;
+async function readChatTabState(cdp, signal) {
   return evaluate(
     cdp,
     `(() => {
-      ${buildClickDispatcher()}
-      const kind = ${JSON.stringify(kind)};
-      const effortChoices = new Set(${JSON.stringify(CHATGPT_EFFORT_CHOICES)});
-      const effortOwnerLabels = new Set([...effortChoices, 'thinking']);
-      const normalize = (value) => String(value || '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
-      const labelFor = (node) => {
-        const labelledBy = String(node.getAttribute?.('aria-labelledby') || '')
-          .split(/\s+/)
-          .map((id) => document.getElementById(id)?.textContent || '')
-          .join(' ');
-        const text = (node.innerText || node.textContent || '').replace(/\s+/g, ' ').trim();
-        const aria = (node.getAttribute?.('aria-label') || '').replace(/\s+/g, ' ').trim();
-        const title = (node.getAttribute?.('title') || '').replace(/\s+/g, ' ').trim();
-        return [text, aria, labelledBy, title].filter(Boolean).join(' | ');
+      const normalize = (value) => String(value || '').replace(/\\s+/g, ' ').trim().toLowerCase();
+      const visible = (node) => {
+        if (!node || node.hasAttribute?.('hidden') || node.getAttribute?.('aria-hidden') === 'true') return false;
+        const style = window.getComputedStyle?.(node);
+        if (style && (style.display === 'none' || style.visibility === 'hidden')) return false;
+        const rect = node.getBoundingClientRect?.();
+        return !rect || (rect.width > 0 && rect.height > 0);
       };
-      let nodes = Array.from(document.querySelectorAll(${JSON.stringify(selector)})).filter((node) => {
-        const value = normalize(labelFor(node));
-        if (kind !== 'model') {
-          const words = value.split(/\s+/).filter(Boolean);
-          const hasEffort = words.some((word) => effortOwnerLabels.has(word));
-          const looksLikeModel = node.getAttribute?.('data-testid') === 'model-switcher-dropdown-button' ||
-            value.includes('current model') || value.includes('gpt') || value.includes('instant');
-          return hasEffort && !looksLikeModel;
-        }
-        return value.includes('gpt') || value.includes('thinking') || value.includes('instant');
+      const selected = (node) => node.getAttribute?.('aria-selected') === 'true' ||
+        node.getAttribute?.('aria-current') === 'page' ||
+        node.getAttribute?.('data-state') === 'active' ||
+        node.getAttribute?.('data-state') === 'selected' ||
+        node.getAttribute?.('data-active') === 'true' ||
+        /\\b(active|selected)\\b/i.test(String(node.className || ''));
+      const labelFor = (node) => [
+        node.innerText || node.textContent || '',
+        node.getAttribute?.('aria-label') || '',
+        node.getAttribute?.('title') || '',
+      ].join(' ').replace(/\\s+/g, ' ').trim();
+      const matchesName = (node, name) => [
+        node.innerText || node.textContent || '',
+        node.getAttribute?.('aria-label') || '',
+        node.getAttribute?.('title') || '',
+      ].some((value) => {
+        const normalized = normalize(value);
+        return normalized === name || normalized === name + ' tab' || normalized === 'switch to ' + name;
       });
-      if (kind === 'model' && nodes.length === 0) {
-        nodes = Array.from(document.querySelectorAll(${JSON.stringify(selector)})).filter((node) => {
-          const value = normalize(labelFor(node));
-          return value.includes('pro');
-        });
-      }
-      if (kind === 'model' && nodes.length === 0) {
-        nodes = Array.from(document.querySelectorAll(${JSON.stringify(selector)})).filter((node) =>
-          node.getAttribute?.('aria-haspopup') === 'menu' || node.getAttribute?.('aria-expanded') !== null
-        );
-      }
-      const items = nodes.map((node) => {
-        const text = (node.innerText || node.textContent || '').replace(/\\s+/g, ' ').trim();
-        const aria = (node.getAttribute?.('aria-label') || '').replace(/\\s+/g, ' ').trim();
-        const labelledBy = String(node.getAttribute?.('aria-labelledby') || '')
-          .split(/\\s+/)
-          .map((id) => document.getElementById(id)?.textContent || '')
-          .join(' ')
-          .replace(/\\s+/g, ' ')
-          .trim();
-        const title = (node.getAttribute?.('title') || '').replace(/\\s+/g, ' ').trim();
-        return {
-          role: node.getAttribute?.('role') || (node.tagName === 'BUTTON' ? 'button' : null),
-          label: [text, aria, labelledBy, title].filter(Boolean).join(' | ').slice(0, 240),
-          displayLabel: (text || aria || labelledBy || title).slice(0, 80),
-          testId: node.getAttribute?.('data-testid') || null,
-        };
+      const nodes = Array.from(new Set([
+        ...document.querySelectorAll('[role="tab"], button, a'),
+      ])).filter(visible);
+      const details = (node) => ({ label: labelFor(node).slice(0, 120), selected: selected(node) });
+      const matches = (name) => nodes
+        .filter((node) => matchesName(node, name))
+        .map(details);
+      return { chat: matches('chat'), work: matches('work') };
+    })()`,
+    signal,
+  );
+}
+
+async function selectChatTab(cdp, timeoutMs = 8000, signal) {
+  throwIfAborted(signal);
+  const read = () => readChatTabState(cdp, signal);
+  let state = await read();
+  if (state?.chat?.length === 1 && state.chat[0].selected) return state.chat[0].label;
+  if (state?.chat?.length === 0 && state?.work?.length > 0) {
+    throw uiError(
+      "chat_mode_unavailable",
+      "ChatGPT only exposes Work mode; the Chat tab is required for Oracle",
+    );
+  }
+  if (state?.chat?.length !== 1) {
+    throw uiError(
+      "chat_mode_selector_drift",
+      state?.chat?.length
+        ? "ChatGPT Chat tab selector drift: Chat tab is ambiguous"
+        : "ChatGPT Chat tab selector drift: Chat tab was not found",
+    );
+  }
+
+  const clicked = await evaluate(
+    cdp,
+    `(() => {
+      ${buildClickDispatcher()}
+      const normalize = (value) => String(value || '').replace(/\\s+/g, ' ').trim().toLowerCase();
+      const matchesName = (node) => [
+        node.innerText || node.textContent || '',
+        node.getAttribute?.('aria-label') || '',
+        node.getAttribute?.('title') || '',
+      ].some((value) => {
+        const normalized = normalize(value);
+        return normalized === 'chat' || normalized === 'chat tab' || normalized === 'switch to chat';
       });
-      if (${click} && nodes.length === 1) dispatchClickSequence(nodes[0]);
-      return { items };
+      const nodes = Array.from(new Set([
+        ...document.querySelectorAll('[role="tab"], button, a'),
+      ])).filter(matchesName);
+      return nodes.length === 1 ? dispatchClickSequence(nodes[0]) : false;
+    })()`,
+    signal,
+  );
+  if (!clicked) {
+    throw uiError("chat_mode_selector_drift", "ChatGPT Chat tab selector drift: Chat tab could not be clicked");
+  }
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await delay(100, signal);
+    state = await read();
+    if (state?.chat?.length === 1 && state.chat[0].selected) return state.chat[0].label;
+    if (state?.chat?.length === 0 && state?.work?.length > 0) {
+      throw uiError(
+        "chat_mode_unavailable",
+        "ChatGPT only exposes Work mode; the Chat tab is required for Oracle",
+      );
+    }
+  }
+  throw uiError("chat_mode_selection_failed", "ChatGPT Chat tab could not be selected before timeout");
+}
+
+async function readGitHubToolState(cdp, signal) {
+  return evaluate(
+    cdp,
+    `(() => {
+      const normalize = (value) => String(value || '').replace(/\\s+/g, ' ').trim().toLowerCase();
+      const visible = (node) => {
+        if (!node || node.hasAttribute?.('hidden') || node.getAttribute?.('aria-hidden') === 'true') return false;
+        const style = window.getComputedStyle?.(node);
+        if (style && (style.display === 'none' || style.visibility === 'hidden')) return false;
+        const rect = node.getBoundingClientRect?.();
+        return !rect || (rect.width > 0 && rect.height > 0);
+      };
+      const labelFor = (node) => [
+        node.innerText || node.textContent || '',
+        node.getAttribute?.('aria-label') || '',
+        node.getAttribute?.('title') || '',
+        node.getAttribute?.('data-testid') || '',
+        node.getAttribute?.('data-tool') || '',
+      ].join(' ').replace(/\\s+/g, ' ').trim();
+      const selected = (node, label) => node.getAttribute?.('aria-checked') === 'true' ||
+        node.getAttribute?.('aria-selected') === 'true' ||
+        node.getAttribute?.('aria-pressed') === 'true' ||
+        node.getAttribute?.('data-selected') === 'true' ||
+        node.getAttribute?.('data-active') === 'true' ||
+        ['checked', 'selected', 'on', 'active'].includes(normalize(node.getAttribute?.('data-state'))) ||
+        /\\b(active|selected)\\b/i.test(label);
+      const controls = Array.from(new Set([
+        ...document.querySelectorAll('[role="menuitem"], [role="option"], [role="button"], button, [data-testid*="github" i], [data-tool*="github" i], [aria-label*="github" i], [title*="github" i]'),
+      ])).filter(visible);
+      const github = controls.filter((node) => normalize(labelFor(node)).includes('github'));
+      return {
+        controls: github.map((node) => {
+          const label = labelFor(node).slice(0, 160);
+          return {
+            label,
+            role: node.getAttribute?.('role') || (node.tagName === 'BUTTON' ? 'button' : null),
+            selected: selected(node, label),
+            disconnected: /\\b(disconnected|not connected|connect|authorize|sign in)\\b/i.test(label),
+            testId: node.getAttribute?.('data-testid') || null,
+          };
+        }),
+      };
     })()`,
+    signal,
   );
 }
 
-async function readMenu(cdp, kind, allowSubmenu) {
-  const isModel = kind === "model";
-  const menuSelector = isModel ? SELECTORS.modelMenu : SELECTORS.effortMenu;
-  const itemSelector = isModel ? SELECTORS.modelMenuItem : SELECTORS.effortMenuItem;
+async function openToolsMenu(cdp, signal) {
   return evaluate(
     cdp,
     `(() => {
       ${buildClickDispatcher()}
-      const isModel = ${isModel};
-      const choices = ${JSON.stringify(CHATGPT_EFFORT_CHOICES)};
-      const containers = Array.from(document.querySelectorAll(${JSON.stringify(menuSelector)}));
-      const normalize = (value) => String(value || '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
-      let menu = isModel ? containers.find((container) => {
-        const labels = Array.from(container.querySelectorAll(${JSON.stringify(itemSelector)}))
-          .filter((item) => item.getAttribute?.('aria-haspopup') !== 'menu')
-          .map((item) => normalize((item.getAttribute?.('aria-label') || '') + ' ' + (item.textContent || '')));
-        return labels.some((label) => label.includes('gpt') || /^o[0-9]/.test(label));
-      }) : containers.find((container) => {
-        const label = normalize(container.querySelector?.(${JSON.stringify(SELECTORS.effortMenuLabel)})?.textContent);
-        const levels = new Set(Array.from(container.querySelectorAll(${JSON.stringify(itemSelector)}))
-          .flatMap((item) => normalize(item.textContent).split(/\\s+/))
-          .filter((word) => choices.includes(word)));
-        return label.includes('thinking time') || levels.size >= 2;
-      });
-      if (!menu && isModel && ${allowSubmenu}) {
-        for (const container of containers) {
-          const trigger = Array.from(container.querySelectorAll(${JSON.stringify(SELECTORS.effortSubmenuTrigger)}))
-            .find((item) => {
-              const label = normalize((item.getAttribute?.('aria-label') || '') + ' ' + (item.textContent || ''));
-              return label.includes('model') || label.includes('advanced');
-            });
-          if (trigger) {
-            dispatchClickSequence(trigger);
-            return { found: false, submenuOpened: true, items: [] };
-          }
-        }
+      const selectors = ${JSON.stringify(SELECTORS.toolsButton.split(", "))};
+      const visible = (node) => {
+        if (!node || node.hasAttribute?.('hidden') || node.getAttribute?.('aria-hidden') === 'true') return false;
+        const style = window.getComputedStyle?.(node);
+        return !style || (style.display !== 'none' && style.visibility !== 'hidden');
+      };
+      for (const selector of selectors) {
+        const node = Array.from(document.querySelectorAll(selector)).find(visible);
+        if (node) return dispatchClickSequence(node);
       }
-      if (!menu && !isModel && ${allowSubmenu}) {
-        for (const container of containers) {
-          const trigger = Array.from(container.querySelectorAll(${JSON.stringify(SELECTORS.effortSubmenuTrigger)}))
-            .find((item) => {
-              const label = normalize((item.getAttribute?.('aria-label') || '') + ' ' + (item.textContent || ''));
-              return label.includes('thinking time') || label.includes('reasoning effort');
-            });
-          if (trigger) {
-            dispatchClickSequence(trigger);
-            return { found: false, submenuOpened: true, items: [] };
-          }
-        }
+      return false;
+    })()`,
+    signal,
+  );
+}
+
+async function clickGitHubTool(cdp, signal) {
+  return evaluate(
+    cdp,
+    `(() => {
+      ${buildClickDispatcher()}
+      const normalize = (value) => String(value || '').replace(/\\s+/g, ' ').trim().toLowerCase();
+      const labelFor = (node) => [
+        node.innerText || node.textContent || '',
+        node.getAttribute?.('aria-label') || '',
+        node.getAttribute?.('title') || '',
+        node.getAttribute?.('data-testid') || '',
+        node.getAttribute?.('data-tool') || '',
+      ].join(' ').replace(/\\s+/g, ' ').trim();
+      const controls = Array.from(new Set([
+        ...document.querySelectorAll('[role="menuitem"], [role="option"], [role="button"], button, [data-testid*="github" i], [data-tool*="github" i], [aria-label*="github" i], [title*="github" i]'),
+      ])).filter((node) => normalize(labelFor(node)).includes('github'));
+      const menuItems = controls.filter((node) => ['menuitem', 'option'].includes(node.getAttribute?.('role')));
+      const candidates = menuItems.length > 0 ? menuItems : controls;
+      return candidates.length === 1 ? dispatchClickSequence(candidates[0]) : false;
+    })()`,
+    signal,
+  );
+}
+
+async function selectGitHubTool(cdp, timeoutMs = 10000, signal) {
+  throwIfAborted(signal);
+  let state = await readGitHubToolState(cdp, signal);
+  const findConnected = () => state?.controls?.filter((control) => !control.disconnected) || [];
+  if (state?.controls?.some((control) => control.disconnected)) {
+    throw uiError(
+      "github_tool_disconnected",
+      "ChatGPT GitHub tool is missing or disconnected; connect GitHub before running Oracle with --github",
+    );
+  }
+  if (findConnected().length === 1 && state.controls[0].selected) return state.controls[0].label;
+  if (state?.controls?.length > 1) {
+    throw uiError("github_tool_selector_drift", "ChatGPT GitHub tool selector drift: GitHub tool is ambiguous");
+  }
+  if (state?.controls?.length === 0) {
+    const opened = await openToolsMenu(cdp, signal);
+    if (!opened) {
+      throw uiError("github_tool_selector_drift", "ChatGPT tools selector drift: tools menu could not be opened");
+    }
+    const menuDeadline = Date.now() + timeoutMs;
+    while (Date.now() < menuDeadline) {
+      await delay(100, signal);
+      state = await readGitHubToolState(cdp, signal);
+      if (state?.controls?.some((control) => control.disconnected)) {
+        throw uiError(
+          "github_tool_disconnected",
+          "ChatGPT GitHub tool is missing or disconnected; connect GitHub before running Oracle with --github",
+        );
+      }
+      if (state?.controls?.length > 0) break;
+    }
+  }
+  if (!state?.controls?.length) {
+    throw uiError("github_tool_missing", "ChatGPT GitHub tool is not available in the tools menu");
+  }
+  if (state.controls.length === 1 && state.controls[0].selected) return state.controls[0].label;
+  if (state.controls.length !== 1 || !(await clickGitHubTool(cdp, signal))) {
+    throw uiError("github_tool_selector_drift", "ChatGPT GitHub tool selector drift: GitHub tool could not be selected");
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await delay(100, signal);
+    state = await readGitHubToolState(cdp, signal);
+    if (state?.controls?.some((control) => control.disconnected)) {
+      throw uiError(
+        "github_tool_disconnected",
+        "ChatGPT GitHub tool became disconnected while selecting it",
+      );
+    }
+    if (state?.controls?.length === 1 && state.controls[0].selected) return state.controls[0].label;
+  }
+  throw uiError("github_tool_selection_failed", "ChatGPT GitHub tool could not be verified after selection");
+}
+
+async function waitForChatGPTAttachment(cdp, filePaths, timeoutMs = 30000, signal) {
+  const expectedNames = (Array.isArray(filePaths) ? filePaths : [filePaths])
+    .map((filePath) => String(filePath).split(/[\\/]/).pop().toLowerCase());
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const state = await evaluate(
+      cdp,
+      `(() => {
+        const scope = document.querySelector('form') || document.querySelector('[data-testid*="composer"]') || document;
+        const text = (scope.innerText || scope.textContent || '').replace(/\\s+/g, ' ').trim();
+        const inputs = Array.from(scope.querySelectorAll?.('input[type="file"]') || []);
+        const fileCount = inputs.reduce((count, input) => count + (input.files?.length || 0), 0);
+        const attachmentNodes = Array.from(scope.querySelectorAll?.('[data-testid*="attachment" i], [data-testid*="file" i], [aria-label*="remove attachment" i], [aria-label*="remove file" i]') || [])
+          .filter((node) => node.tagName !== 'INPUT' || node.type !== 'file');
+        const hasAttachmentNode = attachmentNodes.some((node) => {
+          const rect = node.getBoundingClientRect?.();
+          return !rect || (rect.width > 0 && rect.height > 0);
+        });
+        const attachmentLabels = attachmentNodes
+          .filter((node) => {
+            const rect = node.getBoundingClientRect?.();
+            return !rect || (rect.width > 0 && rect.height > 0);
+          })
+          .map((node) => [
+            node.innerText || node.textContent || '',
+            node.getAttribute?.('aria-label') || '',
+            node.getAttribute?.('title') || '',
+          ].join(' ').replace(/\\s+/g, ' ').trim().toLowerCase())
+          .filter(Boolean);
+        const processingError = /\\b(upload failed|failed to upload|couldn.t upload|unsupported file|file too large|processing failed|error processing)\\b/i.test(text);
+        return { fileCount, hasAttachmentNode, attachmentLabels, processingError, text: text.slice(-300) };
+      })()`,
+      signal,
+    );
+    if (state?.processingError) {
+      throw uiError(
+        "attachment_processing",
+        `ChatGPT attachment processing failed${state.text ? `: ${state.text}` : ""}`,
+      );
+    }
+    const attachmentLabels = Array.isArray(state?.attachmentLabels) ? state.attachmentLabels : [];
+    const hasExpectedName = expectedNames.every((expected) =>
+      attachmentLabels.some((label) => label.includes(expected)),
+    );
+    const hasPotentialFilename = attachmentLabels.some((label) => /(?:^|\\s)[\\w.-]+\\.[a-z0-9]{1,8}(?:$|\\s|[)\\]])/i.test(label));
+    if (state?.hasAttachmentNode && (hasExpectedName || !hasPotentialFilename)) return true;
+    await delay(250, signal);
+  }
+  throw uiError(
+    "attachment_processing",
+    `ChatGPT attachment processing did not complete for ${expectedNames.filter(Boolean).join(", ") || "the selected file"}`,
+  );
+}
+
+function verificationError(kind, requested, items = [], invalid = false) {
+  const safeRequested = String(requested || "").replace(/\s+/g, " ").trim().slice(0, 80);
+  const available = boundedOptionLabels(items);
+  const accepted = kind === "effort" ? ` Accepted: ${CHATGPT_EFFORT_CHOICES.join(", ")}.` : "";
+  const availableMessage = available.length > 0 ? ` Available: ${available.join(", ")}.` : "";
+  const error = new Error(
+    invalid
+      ? `Invalid ChatGPT effort "${safeRequested}".${accepted}`
+      : `ChatGPT ${kind} verification failed for "${safeRequested}".${accepted}${availableMessage}`,
+  );
+  error.code = "model_verification_failed";
+  return error;
+}
+
+
+function combinedPickerScript(click = false) {
+  return `(() => {
+    ${buildClickDispatcher()}
+    const pickerSelector = ${JSON.stringify(SELECTORS.modelButton)};
+    const normalizeText = (value) => String(value || '').replace(/\\s+/g, ' ').trim();
+    const visible = (node) => {
+      if (!node || node.nodeType !== 1) return false;
+      for (let el = node; el && el.nodeType === 1; el = el.parentElement) {
+        if (el.hasAttribute?.('hidden') || el.hasAttribute?.('inert') || el.getAttribute?.('aria-hidden') === 'true') return false;
+        const style = window.getComputedStyle?.(el);
+        if (style && (style.display === 'none' || style.visibility === 'hidden')) return false;
       }
-      if (!menu) return { found: false, items: [] };
-      const items = Array.from(menu.querySelectorAll(${JSON.stringify(itemSelector)})).map((item) => {
-        const primary = isModel ? item.querySelector?.(${JSON.stringify(SELECTORS.menuItemPrimaryLabel)}) : null;
-        const label = (primary?.textContent || item.getAttribute?.('aria-label') || item.textContent || '')
-          .replace(/\\s+/g, ' ').trim().slice(0, 80);
-        const state = (item.getAttribute?.('data-state') || '').toLowerCase();
-        const selected = item.getAttribute?.('aria-checked') === 'true' ||
-          item.getAttribute?.('aria-selected') === 'true' || item.getAttribute?.('data-selected') === 'true' ||
-          ['checked', 'selected', 'on'].includes(state) ||
-          Boolean(item.querySelector?.(${JSON.stringify(SELECTORS.selectedMenuIndicator)}));
+      const rect = node.getBoundingClientRect?.();
+      return !rect || (rect.width > 0 && rect.height > 0);
+    };
+    const labelledText = (node) => {
+      const labelledBy = String(node.getAttribute?.('aria-labelledby') || '')
+        .split(/\\s+/)
+        .map((id) => document.getElementById(id)?.textContent || '')
+        .join(' ');
+      return [node.innerText || node.textContent || '', node.getAttribute?.('aria-label') || '', labelledBy, node.getAttribute?.('title') || '']
+        .map(normalizeText)
+        .filter(Boolean)
+        .join(' | ');
+    };
+    const directSpanText = (node) => Array.from(node?.children || [])
+      .filter((child) => child.tagName === 'SPAN')
+      .filter(visible)
+      .map((span) => normalizeText(span.innerText || span.textContent || ''))
+      .filter(Boolean)
+      .filter((label, index, labels) => labels.indexOf(label) === index)
+      .join(' ');
+    const itemFor = (node, fallbackLabel) => {
+      const text = normalizeText(directSpanText(node) || node.innerText || node.textContent || '');
+      const aria = normalizeText(node.getAttribute?.('aria-label') || '');
+      const labelled = labelledText(node);
+      const label = [text, aria, labelled]
+        .filter(Boolean)
+        .filter((value, index, values) => values.indexOf(value) === index)
+        .join(' | ');
+      const modelText = text.toLowerCase();
+      const modelKey = /\\b5\\.6\\b/.test(modelText) && /\\bsol\\b/.test(modelText)
+        ? 'gpt56sol'
+        : /\\b5\\.5\\b/.test(modelText)
+          ? 'gpt55'
+          : (/\\bgpt\\s*6\\b/.test(modelText) || /^6(?:\\s|$)/.test(modelText))
+            ? 'gpt6astra'
+            : /^latest$/.test(modelText)
+              ? 'latest'
+              : null;
+      return {
+        role: node.getAttribute?.('role') || (node.tagName === 'BUTTON' ? 'button' : null),
+        label: (label || fallbackLabel || '').slice(0, 240),
+        displayLabel: (text || aria || fallbackLabel || '').slice(0, 80),
+        testId: node.getAttribute?.('data-testid') || null,
+        ...(modelKey ? { modelKey } : {}),
+      };
+    };
+    const buttons = Array.from(document.querySelectorAll(pickerSelector)).filter((node) =>
+      visible(node) && (node.getAttribute?.('aria-haspopup') === 'menu' || node.getAttribute?.('aria-expanded') !== null)
+    );
+    const pickerButtons = buttons.map((node) => itemFor(node));
+    if (${click} && buttons.length === 1) dispatchClickSequence(buttons[0]);
+
+    const menus = Array.from(document.querySelectorAll('[role="menu"][data-radix-menu-content]')).filter(visible);
+    const menu = menus.find((node) => node.querySelector?.('[data-testid="composer-intelligence-picker-content"]')) || menus[0] || null;
+    if (!menu) return { pickerButtons, menuFound: false, modelItems: pickerButtons, effortItems: [] };
+
+    const content = menu.querySelector?.('[data-testid="composer-intelligence-picker-content"]') || menu;
+    const panels = Array.from(content.querySelectorAll?.('[data-testid="composer-model-picker-slider-simple-view"], [data-testid="composer-model-picker-slider-advanced-view"], [data-view="simple"], [data-view="advanced"]') || [])
+      .filter(visible);
+    const activePanel = panels.find((panel) => !panel.hasAttribute?.('inert')) || content;
+    const activeId = activePanel.getAttribute?.('data-testid') || '';
+    const view = activePanel.getAttribute?.('data-view') || (activeId.includes('advanced') ? 'advanced' : 'simple');
+
+    const modelToggle = Array.from(content.querySelectorAll?.('[role="menuitem"][aria-label="Select model"]') || [])
+      .filter(visible)[0] || null;
+    const modelToggleItem = modelToggle ? itemFor(modelToggle) : null;
+    const modelOptions = Array.from(activePanel.querySelectorAll?.('[role="menuitemradio"]') || [])
+      .filter(visible)
+      .map((node) => {
+        const item = itemFor(node);
+        const state = String(node.getAttribute?.('data-state') || '').toLowerCase();
         return {
-          role: item.getAttribute?.('role') || (item.tagName === 'BUTTON' ? 'button' : null),
-          label,
-          testId: item.getAttribute?.('data-testid') || null,
-          selected,
+          ...item,
+          selected: node.getAttribute?.('aria-checked') === 'true' || state === 'checked',
         };
-      });
-      return { found: true, items };
-    })()`,
-  );
+      })
+      .filter((item) => /\\b(latest|gpt|5\\.6|5\\.5)\\b/i.test(item.label));
+
+    const power = Array.from(content.querySelectorAll?.('[role="menuitem"][aria-label="Power"]') || [])
+      .filter(visible)[0] || null;
+    let effortItems = [];
+    if (power) {
+      const slider = power.querySelector?.('[data-model-reasoning-effort-slider] [role="slider"]') || power.querySelector?.('[role="slider"]');
+      if (slider) {
+        const describedBy = String(power.getAttribute?.('aria-describedby') || slider.getAttribute?.('aria-describedby') || '')
+          .split(/\\s+/)
+          .map((id) => normalizeText(document.getElementById(id)?.textContent || ''))
+          .filter(Boolean)
+          .join(' | ');
+        const ariaValueText = normalizeText(slider.getAttribute?.('aria-valuetext') || '');
+        const powerText = normalizeText(power.innerText || power.textContent || '');
+        effortItems = [{
+          role: 'slider',
+          label: [ariaValueText, describedBy, powerText].filter(Boolean).join(' | ').slice(0, 240),
+          displayLabel: (ariaValueText || describedBy || powerText).slice(0, 80),
+          value: Number(slider.getAttribute?.('aria-valuenow')),
+          min: Number(slider.getAttribute?.('aria-valuemin')),
+          max: Number(slider.getAttribute?.('aria-valuemax')),
+          selected: true,
+        }];
+      }
+    }
+
+    return {
+      pickerButtons,
+      menuFound: true,
+      view,
+      modelToggle: modelToggleItem,
+      modelToggleExpanded: modelToggle?.getAttribute?.('aria-expanded') === 'true',
+      modelOptions,
+      modelItems: [...(modelToggleItem ? [modelToggleItem] : []), ...modelOptions.filter((item) => item.selected)],
+      effortItems,
+    };
+  })()`;
+}
+
+async function readCombinedPicker(cdp, click = false, signal) {
+  return evaluate(cdp, combinedPickerScript(click), signal);
 }
 
-async function waitForMenu(cdp, kind, timeoutMs, signal) {
+async function waitForCombinedMenu(cdp, timeoutMs, signal) {
   const deadline = Date.now() + timeoutMs;
-  let allowSubmenu = true;
   while (Date.now() < deadline) {
-    const result = await readMenu(cdp, kind, allowSubmenu);
-    if (result?.found) return result;
-    if (result?.submenuOpened) allowSubmenu = false;
+    const result = await readCombinedPicker(cdp, false, signal);
+    if (result?.menuFound) return result;
     await delay(100, signal);
   }
-  return { found: false, items: [] };
+  return { menuFound: false, modelItems: [], modelOptions: [], effortItems: [] };
+}
+
+async function activateAdvancedModelView(cdp, signal) {
+  return evaluate(
+    cdp,
+    `(() => {
+      ${buildClickDispatcher()}
+      const visible = (node) => {
+        if (!node || node.nodeType !== 1) return false;
+        for (let el = node; el && el.nodeType === 1; el = el.parentElement) {
+          if (el.hasAttribute?.('hidden') || el.hasAttribute?.('inert') || el.getAttribute?.('aria-hidden') === 'true') return false;
+          const style = window.getComputedStyle?.(el);
+          if (style && (style.display === 'none' || style.visibility === 'hidden')) return false;
+        }
+        const rect = node.getBoundingClientRect?.();
+        return !rect || (rect.width > 0 && rect.height > 0);
+      };
+      const trigger = Array.from(document.querySelectorAll('[role="menuitem"][aria-label="Select model"]')).filter(visible)[0];
+      if (!trigger) return false;
+      if (trigger.getAttribute?.('aria-expanded') === 'true') return true;
+      return dispatchClickSequence(trigger);
+    })()`,
+    signal,
+  );
 }
 
-async function clickMenuItem(cdp, kind, match) {
-  const isModel = kind === "model";
-  const menuSelector = isModel ? SELECTORS.modelMenu : SELECTORS.effortMenu;
-  const itemSelector = isModel ? SELECTORS.modelMenuItem : SELECTORS.effortMenuItem;
+async function clickModelOption(cdp, match, signal) {
   return evaluate(
     cdp,
     `(() => {
       ${buildClickDispatcher()}
       const expectedTestId = ${JSON.stringify(match.testId)};
       const expectedLabel = ${JSON.stringify(match.label)};
-      const items = Array.from(new Set(
-        Array.from(document.querySelectorAll(${JSON.stringify(menuSelector)}))
-          .flatMap((menu) => Array.from(menu.querySelectorAll(${JSON.stringify(itemSelector)}))),
-      ));
-      const matches = items.filter((item) => {
+      const normalizeText = (value) => String(value || '').replace(/\\s+/g, ' ').trim();
+      const visible = (node) => {
+        if (!node || node.nodeType !== 1) return false;
+        for (let el = node; el && el.nodeType === 1; el = el.parentElement) {
+          if (el.hasAttribute?.('hidden') || el.hasAttribute?.('inert') || el.getAttribute?.('aria-hidden') === 'true') return false;
+          const style = window.getComputedStyle?.(el);
+          if (style && (style.display === 'none' || style.visibility === 'hidden')) return false;
+        }
+        const rect = node.getBoundingClientRect?.();
+        return !rect || (rect.width > 0 && rect.height > 0);
+      };
+      const menu = Array.from(document.querySelectorAll('[role="menu"][data-radix-menu-content]')).filter(visible)[0];
+      const content = menu?.querySelector?.('[data-testid="composer-intelligence-picker-content"]') || menu;
+      const panels = Array.from(content?.querySelectorAll?.('[data-testid="composer-model-picker-slider-advanced-view"], [data-view="advanced"]') || []).filter(visible);
+      const panel = panels.find((node) => !node.hasAttribute?.('inert')) || content;
+      const matches = Array.from(panel?.querySelectorAll?.('[role="menuitemradio"]') || []).filter(visible).filter((item) => {
         if (expectedTestId) return item.getAttribute?.('data-testid') === expectedTestId;
-        const primary = ${isModel} ? item.querySelector?.(${JSON.stringify(SELECTORS.menuItemPrimaryLabel)}) : null;
-        const label = (primary?.textContent || item.getAttribute?.('aria-label') || item.textContent || '')
-          .replace(/\\s+/g, ' ').trim().slice(0, 80);
+        const label = normalizeText(item.innerText || item.textContent || item.getAttribute?.('aria-label') || '').slice(0, 240);
         return label === expectedLabel;
       });
-      return matches.length >= 1 ? dispatchClickSequence(matches[0]) : false;
+      return matches.length === 1 ? dispatchClickSequence(matches[0]) : false;
     })()`,
+    signal,
   );
 }
 
-async function selectModel(cdp, desiredModel, timeoutMs = 8000, signal) {
+async function closeCombinedPicker(cdp, inputCdp, signal) {
+  const hasMenu = (await readCombinedPicker(cdp, false, signal))?.menuFound;
+  if (!hasMenu) return;
+  if (inputCdp) {
+    await inputCdp("Input.dispatchKeyEvent", { type: "keyDown", key: "Escape", code: "Escape", windowsVirtualKeyCode: 27 });
+    await inputCdp("Input.dispatchKeyEvent", { type: "keyUp", key: "Escape", code: "Escape", windowsVirtualKeyCode: 27 });
+  } else {
+    await evaluate(cdp, `document.activeElement?.blur?.(); document.body?.click?.(); true`, signal);
+  }
+  const deadline = Date.now() + 1000;
+  while (Date.now() < deadline) {
+    await delay(50, signal);
+    if (!(await readCombinedPicker(cdp, false, signal))?.menuFound) return;
+  }
+  throw uiError("picker_close_failed", "ChatGPT picker did not close after Escape/outside click");
+}
+
+async function verifyCurrentModel(cdp, inputCdp, desiredModel, timeoutMs = 8000, signal) {
   throwIfAborted(signal);
-  const picker = await readPicker(cdp, "model", true);
-  if (picker?.items?.length !== 1) throw verificationError("model", desiredModel);
-  await delay(300, signal);
-  const menu = await waitForMenu(cdp, "model", timeoutMs, signal);
-  const currentAdvancedModel = verifyChatGPTModelSelection(
-    menu.items.filter((item) => /\bmodel\b/i.test(String(item?.label || ""))),
-    desiredModel,
-  );
-  if (currentAdvancedModel) return currentAdvancedModel.displayLabel || currentAdvancedModel.label;
+  const state = await readCombinedPicker(cdp, false, signal);
+  const verified = verifyChatGPTModelSelection(state?.modelItems, desiredModel);
+  if (verified) {
+    await closeCombinedPicker(cdp, inputCdp, signal);
+    return verified.displayLabel || verified.label;
+  }
+  let menu = state?.menuFound ? state : null;
+  if (!menu) {
+    const opened = await readCombinedPicker(cdp, true, signal);
+    if (opened?.pickerButtons?.length !== 1) throw verificationError("model", desiredModel, state?.modelItems);
+    await delay(150, signal);
+    menu = await waitForCombinedMenu(cdp, timeoutMs, signal);
+  }
+  let readback = verifyChatGPTModelSelection(menu.modelItems, desiredModel);
+  if (!readback) {
+    if (!(await activateAdvancedModelView(cdp, signal))) throw verificationError("model", desiredModel, menu.modelItems);
+    await delay(150, signal);
+    menu = await waitForCombinedMenu(cdp, timeoutMs, signal);
+    readback = verifyChatGPTModelSelection(menu.modelItems, desiredModel);
+  }
+  if (!readback) throw verificationError("model", desiredModel, menu.modelItems);
+  await closeCombinedPicker(cdp, inputCdp, signal);
+  return readback.displayLabel || readback.label;
+}
 
-  const match = resolveChatGPTModelMenuOption(menu.items, desiredModel);
-  if (!match || !(await clickMenuItem(cdp, "model", match))) {
-    throw verificationError("model", desiredModel, menu.items);
+async function selectModel(cdp, inputCdp, desiredModel, timeoutMs = 8000, signal) {
+  throwIfAborted(signal);
+  const picker = await readCombinedPicker(cdp, true, signal);
+  if (picker?.pickerButtons?.length !== 1) throw verificationError("model", desiredModel);
+  await delay(200, signal);
+  let menu = await waitForCombinedMenu(cdp, timeoutMs, signal);
+  const current = verifyChatGPTModelSelection(menu.modelItems, desiredModel);
+  if (current) {
+    await closeCombinedPicker(cdp, inputCdp, signal);
+    return current.displayLabel || current.label;
+  }
+
+  if (!(await activateAdvancedModelView(cdp, signal))) throw verificationError("model", desiredModel, menu.modelItems);
+  await delay(150, signal);
+  menu = await waitForCombinedMenu(cdp, timeoutMs, signal);
+  const selectedCurrent = verifyChatGPTModelSelection(menu.modelItems, desiredModel);
+  if (selectedCurrent) {
+    await closeCombinedPicker(cdp, inputCdp, signal);
+    return selectedCurrent.displayLabel || selectedCurrent.label;
+  }
+  const match = resolveChatGPTModelMenuOption(menu.modelOptions, desiredModel);
+  if (!match || !(await clickModelOption(cdp, match, signal))) {
+    throw verificationError("model", desiredModel, menu.modelOptions);
   }
   await delay(200, signal);
-  const state = await readPicker(cdp, "model");
-  const verified = verifyChatGPTModelSelection(state?.items, desiredModel);
-  if (verified) return verified.displayLabel || verified.label;
-
-  const reopened = await readPicker(cdp, "model", true);
-  if (reopened?.items?.length !== 1) throw verificationError("model", desiredModel, menu.items);
-  const readbackMenu = await waitForMenu(cdp, "model", timeoutMs, signal);
-  const readbackVerified = verifyChatGPTModelSelection(
-    readbackMenu.items.filter((item) => item.selected),
-    desiredModel,
+  return verifyCurrentModel(cdp, inputCdp, desiredModel, timeoutMs, signal);
+}
+
+async function focusPowerControl(cdp, signal) {
+  return evaluate(
+    cdp,
+    `(() => {
+      const visible = (node) => {
+        if (!node || node.nodeType !== 1) return false;
+        for (let el = node; el && el.nodeType === 1; el = el.parentElement) {
+          if (el.hasAttribute?.('hidden') || el.hasAttribute?.('inert') || el.getAttribute?.('aria-hidden') === 'true') return false;
+          const style = window.getComputedStyle?.(el);
+          if (style && (style.display === 'none' || style.visibility === 'hidden')) return false;
+        }
+        const rect = node.getBoundingClientRect?.();
+        return !rect || (rect.width > 0 && rect.height > 0);
+      };
+      const power = Array.from(document.querySelectorAll('[role="menuitem"][aria-label="Power"]')).filter(visible)[0];
+      if (!power) return false;
+      power.focus?.();
+      return true;
+    })()`,
+    signal,
   );
-  if (!readbackVerified) throw verificationError("model", desiredModel, readbackMenu.items);
-  return readbackVerified.label;
 }
 
-async function selectEffort(cdp, desiredEffort, timeoutMs = 8000, signal) {
+async function dispatchEffortArrow(cdp, inputCdp, key, signal) {
+  if (inputCdp) {
+    const code = key === "ArrowRight" ? 39 : 37;
+    await inputCdp("Input.dispatchKeyEvent", { type: "keyDown", key, code: key, windowsVirtualKeyCode: code });
+    await inputCdp("Input.dispatchKeyEvent", { type: "keyUp", key, code: key, windowsVirtualKeyCode: code });
+    return;
+  }
+  await evaluate(cdp, `(() => {
+    const key = ${JSON.stringify(key)};
+    const power = document.activeElement || Array.from(document.querySelectorAll('[role="menuitem"][aria-label="Power"]'))[0];
+    power?.dispatchEvent?.(new KeyboardEvent('keydown', { key, code: key, bubbles: true, cancelable: true }));
+    power?.dispatchEvent?.(new KeyboardEvent('keyup', { key, code: key, bubbles: true, cancelable: true }));
+    return true;
+  })()`, signal);
+}
+
+function strictVerifiedEffort(items, desiredEffort) {
+  const verified = verifyChatGPTEffortSelection(items, desiredEffort);
+  if (!verified) return null;
+  return verified.min === 0 && verified.max === 4 && Number.isInteger(verified.value) ? verified : null;
+}
+
+async function selectEffort(cdp, inputCdp, desiredEffort, timeoutMs = 8000, signal) {
   throwIfAborted(signal);
   const normalizedEffort = normalizeChatGPTEffortChoice(desiredEffort);
   if (!normalizedEffort) throw verificationError("effort", desiredEffort, [], true);
-  const current = await readPicker(cdp, "effort");
-  const currentVerified = verifyChatGPTEffortSelection(current?.items, normalizedEffort);
-  if (currentVerified) return currentVerified.displayLabel || currentVerified.label;
+  const targetValue = CHATGPT_EFFORT_VALUE.get(normalizedEffort);
 
-  const picker = await readPicker(cdp, "effort", true);
-  if (picker?.items?.length !== 1) throw verificationError("effort", desiredEffort);
-  await delay(300, signal);
-  const menu = await waitForMenu(cdp, "effort", timeoutMs, signal);
-  const match = resolveChatGPTEffortMenuOption(menu.items, normalizedEffort);
-  if (!match || !(await clickMenuItem(cdp, "effort", match))) {
-    throw verificationError("effort", desiredEffort, menu.items);
-  }
+  const picker = await readCombinedPicker(cdp, true, signal);
+  if (picker?.pickerButtons?.length !== 1) throw verificationError("effort", desiredEffort);
   await delay(200, signal);
-  const pillState = await readPicker(cdp, "effort");
-  const pillVerified = verifyChatGPTEffortSelection(pillState?.items, normalizedEffort);
-  if (pillVerified) return pillVerified.displayLabel || pillVerified.label;
-
-  const reopened = await readPicker(cdp, "effort", true);
-  if (reopened?.items?.length !== 1) throw verificationError("effort", desiredEffort, menu.items);
-  const readbackMenu = await waitForMenu(cdp, "effort", timeoutMs, signal);
-  const verified = verifyChatGPTEffortSelection(
-    readbackMenu.items.filter((item) => item.selected),
-    normalizedEffort,
-  );
-  if (!verified) throw verificationError("effort", desiredEffort, readbackMenu.items);
-  return verified.label;
+  let menu = await waitForCombinedMenu(cdp, timeoutMs, signal);
+  const current = strictVerifiedEffort(menu.effortItems, normalizedEffort);
+  if (current) {
+    await closeCombinedPicker(cdp, inputCdp, signal);
+    return current.displayLabel || current.label;
+  }
+  const effort = menu.effortItems?.[0];
+  if (!effort || effort.min !== 0 || effort.max !== 4 || !Number.isInteger(effort.value) || !Number.isInteger(targetValue)) {
+    throw verificationError("effort", desiredEffort, menu.effortItems);
+  }
+  if (!verifyChatGPTEffortSelection(menu.effortItems, CHATGPT_EFFORT_CHOICES[effort.value])) {
+    throw verificationError("effort", desiredEffort, menu.effortItems);
+  }
+  if (!(await focusPowerControl(cdp, signal))) throw verificationError("effort", desiredEffort, menu.effortItems);
+  const direction = targetValue > effort.value ? "ArrowRight" : "ArrowLeft";
+  for (let index = 0; index < Math.abs(targetValue - effort.value); index += 1) {
+    await dispatchEffortArrow(cdp, inputCdp, direction, signal);
+    await delay(100, signal);
+  }
+  menu = await waitForCombinedMenu(cdp, timeoutMs, signal);
+  const verified = strictVerifiedEffort(menu.effortItems, normalizedEffort);
+  if (!verified) throw verificationError("effort", desiredEffort, menu.effortItems);
+  await closeCombinedPicker(cdp, inputCdp, signal);
+  return verified.displayLabel || verified.label;
 }
 
 async function typePrompt(cdp, inputCdp, prompt, signal) {
@@ -552,10 +977,14 @@ module.exports = {
   normalizeChatGPTModelChoice,
   resolveChatGPTEffortMenuOption,
   resolveChatGPTModelMenuOption,
+  selectChatTab,
   selectEffort,
+  selectGitHubTool,
   selectModel,
+  verifyCurrentModel,
   verifyChatGPTEffortSelection,
   verifyChatGPTModelSelection,
+  waitForChatGPTAttachment,
   typePrompt,
   waitForPageLoad,
   waitForPromptReady,