codex-chatgpt-control 0.2.0-alpha.1 → 0.3.0-alpha.1

package/dist/src/commands/modes.js

@@ -1,11 +1,15 @@
 import { resultError, resultOk } from "../errors.js";
 import { enumerateVisibleMenuItems, findUniqueMenuItem } from "../dom/menus.js";
 import { localeLabels } from "../dom/locale-labels.js";
+import { isShortLatinToken, normalizeForLabelMatch, visibleLabelMatches } from "../dom/label-match.js";
 import { normalizeLabel, normalizeWhitespace } from "../dom/visible-text.js";
 import { contextFromPage } from "./context.js";
 import { bootstrap } from "./session.js";
 const DEFAULT_MODE_EFFORT = "Thinking";
-const CURRENT_MODE_LABELS = [...localeLabels.modeLabels];
+const CURRENT_MODE_LABELS = dedupeLabels([
+    ...localeLabels.modeLabels,
+    ...Object.values(localeLabels.modeOptions).flat(),
+]);
 const MODE_OPENER_LABELS = [...CURRENT_MODE_LABELS.filter(label => label !== "Pro"), ...localeLabels.modeOpenerExtra];
 const MODEL_VERSION_FAMILY_PATTERN = /^gpt[\s-]/i;
 const MODEL_VERSION_LABEL_PATTERN = /^(?:o\d+|\d+(?:\.\d+)?)$/i;
@@ -13,9 +17,33 @@ const CANONICAL_INTELLIGENCE_ORDER = new Map([
     ["instant", 0],
     ["medium", 1],
     ["high", 2],
-    ["extra high", 3],
+    ["extraHigh", 3],
     ["pro", 4],
 ]);
+const MODE_OPTION_IDS = [
+    "latest",
+    "instant",
+    "thinking",
+    "extended",
+    "medium",
+    "high",
+    "extraHigh",
+    "pro",
+];
+const MODE_ID_ALIASES = {
+    latest: ["latest"],
+    instant: ["instant"],
+    thinking: ["thinking"],
+    extended: ["extended"],
+    medium: ["medium"],
+    high: ["high"],
+    extraHigh: ["extra high", "extra-high", "extra_high", "extrahigh"],
+    pro: ["pro"],
+};
+const THREAD_ACTION_MENU_LABELS = new Set(localeLabels.threadActionMenuItems.map(normalizeForLabelMatch));
+const THREAD_ACTION_PREFIXES = localeLabels.threadActionPrefixes
+    .map(normalizeForLabelMatch)
+    .filter(prefix => prefix.length > 0);
 export async function setMode(env, args) {
     const boot = await ensurePage(env);
     if (!boot.ok) {
@@ -23,9 +51,9 @@ export async function setMode(env, args) {
     }
     const page = env.page;
     try {
-        const requested = requestedModeLabels(args);
+        const requested = requestedModeSelections(args);
         const requestedVersion = requestedModelVersion(args);
-        const requestedForOpening = requestedVersion === undefined ? requested : [...requested, requestedVersion];
+        const requestedForOpening = requestedVersion === undefined ? requested : [...requested, requestedModeSelection(requestedVersion)];
         const opened = await waitForModeMenu(page, requestedForOpening, args.timeoutMs ?? 30000);
         if (requestedVersion === undefined && opened.alreadySelected.length === requested.length) {
             return resultOk({ selected: opened.alreadySelected, candidates: opened.modeButtons }, await contextFromPage(page));
@@ -36,15 +64,25 @@ export async function setMode(env, args) {
         await page.waitForTimeout?.(250);
         const candidates = await enumerateVisibleMenuItems(page);
         const selected = [];
-        for (const item of requested) {
-            const match = findModeMenuItem(candidates, item);
+        if (requested.length > 0 && shouldRejectAsWrongModeMenu(candidates)) {
+            const candidateLabels = candidates.map(candidate => candidate.label);
+            return {
+                ok: false,
+                status: "unsupported",
+                warnings: [],
+                blocker: selectorDriftBlocker("Visible menu appears to be a thread/action menu, not the ChatGPT mode menu.", candidateLabels),
+                context: await contextFromPage(page)
+            };
+        }
+        for (const request of requested) {
+            const match = findModeMenuItem(candidates, request);
             if (match === undefined) {
                 const candidateLabels = candidates.map(candidate => candidate.label);
                 return {
                     ok: false,
                     status: "unsupported",
                     warnings: [],
-                    blocker: selectorDriftBlocker(`Mode option "${item}" was not found or was ambiguous.`, candidateLabels),
+                    blocker: selectorDriftBlocker(`Mode option "${request.requested}" was not found or was ambiguous.`, candidateLabels),
                     context: await contextFromPage(page)
                 };
             }
@@ -68,7 +106,53 @@ export async function setMode(env, args) {
             }
             selected.push(versionResult.selected);
         }
-        return resultOk({ selected, candidates: candidateLabels }, await contextFromPage(page));
+        const verificationWarnings = await modeVerificationWarnings(page, requested, selected);
+        return resultOk({ selected, candidates: candidateLabels }, await contextFromPage(page), verificationWarnings);
+    }
+    catch (error) {
+        return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
+    }
+}
+/**
+ * Post-condition check: after clicking mode rows, the composer's mode-labelled controls
+ * should reflect the requested selection. A mismatch does not fail the command — some
+ * ChatGPT surfaces do not echo every mode — but it must be visible to callers so a
+ * modes.set "ok" is never silently treated as a verified mode (the "Pin ... Pro ..."
+ * incident shape). Model-version selections are not verified because versions are
+ * usually not echoed on the composer.
+ */
+async function modeVerificationWarnings(page, requested, selected) {
+    if (requested.length === 0) {
+        return [];
+    }
+    await page.waitForTimeout?.(250);
+    const visibleButtons = await visibleModeButtonLabelList(page);
+    if (visibleButtons.length === 0) {
+        return [
+            `Mode selection is unverified: no mode-labelled composer control was visible after selecting ${selected.map(label => JSON.stringify(label)).join(", ")}. Use modes.get or inspect modeStep before treating this as a verified mode.`
+        ];
+    }
+    const unverified = requested.filter(request => findUniqueVisibleLabelForRequest(visibleButtons, request) === undefined);
+    if (unverified.length === 0) {
+        return [];
+    }
+    return [
+        `Mode selection is unverified: requested ${unverified.map(request => JSON.stringify(request.requested)).join(", ")} is not reflected by the visible mode controls (${visibleButtons.join(", ")}). Use modes.get or inspect modeStep before treating this as a verified mode.`
+    ];
+}
+export async function getMode(env, args = {}) {
+    void args;
+    const boot = await ensurePage(env);
+    if (!boot.ok) {
+        return boot;
+    }
+    const page = env.page;
+    try {
+        const modes = await visibleModeButtonLabelList(page);
+        const warnings = modes.length === 0
+            ? ["No mode-labelled composer control is currently visible, so the active ChatGPT mode could not be read."]
+            : [];
+        return resultOk({ modes }, await contextFromPage(page), warnings);
     }
     catch (error) {
         return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
@@ -84,7 +168,7 @@ async function waitForModeMenu(page, requested, timeoutMs) {
             return { opened: false, alreadySelected, modeButtons };
         }
         const openMenuItems = await enumerateVisibleMenuItems(page);
-        if (looksLikeModeMenu(openMenuItems.map(item => item.label))) {
+        if (looksLikeModeMenu(openMenuItems)) {
             return { opened: true, alreadySelected: [], modeButtons };
         }
         if (await clickModeOpener(page, modeButtons)) {
@@ -165,12 +249,57 @@ async function clickModeOpener(page, modeButtons) {
     }
     return clickFirstUniqueButton(page, MODE_OPENER_LABELS);
 }
-function looksLikeModeMenu(labels) {
-    return labels.some(label => {
-        const normalized = normalizeLabel(label);
-        return CURRENT_MODE_LABELS.some(modeLabel => visibleLabelMatches(normalized, normalizeLabel(modeLabel)));
+function isThreadActionLabel(label) {
+    const normalized = normalizeForLabelMatch(label);
+    if (THREAD_ACTION_MENU_LABELS.has(normalized)) {
+        return true;
+    }
+    return THREAD_ACTION_PREFIXES.some(prefix => normalized.startsWith(`${prefix} `));
+}
+function hasStructuralModeEvidence(item) {
+    if (item.testId?.startsWith("model-switcher-") === true) {
+        return true;
+    }
+    return MODEL_VERSION_FAMILY_PATTERN.test(item.label) || MODEL_VERSION_LABEL_PATTERN.test(item.label);
+}
+/**
+ * Whether a single menu item is evidence that the visible menu is the ChatGPT mode menu.
+ *
+ * A fuzzy token hit on a short mode word such as "Pro" is NOT evidence: thread titles
+ * inside sidebar action menus can contain it ("Pin CopyBench Pro Consultation"), which is
+ * exactly the false positive that let modes.set select a pin action as the Pro mode.
+ * Thread-action rows can never be evidence, even when their title embeds a full mode word.
+ * Exact matching uses normalizeForLabelMatch (NFKC) so the evidence set and the veto set
+ * share identical Unicode folding — fullwidth/compatibility-form labels match both sides.
+ */
+function isModeMenuEvidence(item) {
+    if (hasStructuralModeEvidence(item)) {
+        return true;
+    }
+    if (isThreadActionLabel(item.label)) {
+        return false;
+    }
+    const normalized = normalizeForLabelMatch(item.label);
+    return CURRENT_MODE_LABELS.some(modeLabel => {
+        const normalizedMode = normalizeForLabelMatch(modeLabel);
+        if (normalized === normalizedMode) {
+            return true;
+        }
+        return !isShortLatinToken(normalizedMode) && visibleLabelMatches(normalized, normalizedMode);
     });
 }
+function looksLikeModeMenu(items) {
+    return items.some(item => isModeMenuEvidence(item));
+}
+function shouldRejectAsWrongModeMenu(items) {
+    if (items.length === 0) {
+        return false;
+    }
+    if (items.some(item => isModeMenuEvidence(item))) {
+        return false;
+    }
+    return items.some(item => isThreadActionLabel(item.label));
+}
 async function clickMenuItem(page, label) {
     if (await clickModelSwitcherMenuItem(page, label)) {
         return true;
@@ -262,28 +391,81 @@ function toolLabels(tool) {
     const known = localeLabels.tools[tool];
     return known !== undefined ? [...known] : [tool];
 }
-function findModeMenuItem(candidates, wanted) {
-    const exact = findUniqueMenuItem(candidates, wanted);
-    if (exact !== undefined) {
-        return exact;
+function findModeMenuItem(candidates, request) {
+    const selectable = candidates.filter(candidate => !isThreadActionLabel(candidate.label));
+    for (const wanted of request.labels) {
+        const match = findUniqueModeMenuItem(selectable, wanted);
+        if (match !== undefined) {
+            return match;
+        }
     }
-    const wantedIndex = CANONICAL_INTELLIGENCE_ORDER.get(normalizeLabel(wanted));
+    const wantedIndex = request.modeId === undefined ? undefined : CANONICAL_INTELLIGENCE_ORDER.get(request.modeId);
     if (wantedIndex === undefined) {
         return undefined;
     }
-    const intelligenceItems = candidates.filter(candidate => candidate.role === "menuitemradio"
+    const intelligenceItems = selectable.filter(candidate => candidate.role === "menuitemradio"
         && !MODEL_VERSION_LABEL_PATTERN.test(candidate.label)
         && !MODEL_VERSION_FAMILY_PATTERN.test(candidate.label));
     return intelligenceItems.length >= CANONICAL_INTELLIGENCE_ORDER.size
         ? intelligenceItems[wantedIndex]
         : undefined;
 }
-function requestedModeLabels(args) {
+/**
+ * Unique-match a wanted mode label. Exact normalized equality is always accepted; a
+ * fuzzy token hit on a short mode word such as "Pro" additionally requires structural
+ * mode-row evidence (a model-switcher test id or a menuitemradio role), so an arbitrary
+ * unique menu row whose text merely contains "Pro" cannot be selected as the mode.
+ * Exact matching uses normalizeForLabelMatch (NFKC), consistent with isModeMenuEvidence.
+ */
+function findUniqueModeMenuItem(items, wanted) {
+    const normalizedWanted = normalizeForLabelMatch(wanted);
+    const exact = items.filter(item => normalizeForLabelMatch(item.label) === normalizedWanted);
+    if (exact.length === 1) {
+        return exact[0];
+    }
+    const fuzzy = items.filter(item => visibleLabelMatches(item.label, wanted));
+    if (fuzzy.length !== 1) {
+        return undefined;
+    }
+    const match = fuzzy[0];
+    if (!isShortLatinToken(normalizedWanted)) {
+        return match;
+    }
+    return hasStructuralModeEvidence(match) || match.role === "menuitemradio" ? match : undefined;
+}
+function requestedModeSelections(args) {
     const requested = [args.model, args.intelligence, args.effort].filter((value) => value !== undefined);
     if (requestedModelVersion(args) !== undefined && requested.length === 0) {
         return [];
     }
-    return requested.length > 0 ? requested : [DEFAULT_MODE_EFFORT];
+    return (requested.length > 0 ? requested : [DEFAULT_MODE_EFFORT]).map(requestedModeSelection);
+}
+function requestedModeSelection(requested) {
+    const modeId = modeOptionIdFor(requested);
+    const labels = modeId === undefined ? [requested] : localeLabels.modeOptions[modeId];
+    const request = {
+        requested,
+        labels: labels.length > 0 ? [...labels] : [requested],
+    };
+    if (modeId !== undefined) {
+        request.modeId = modeId;
+    }
+    return request;
+}
+function modeOptionIdFor(value) {
+    const normalized = normalizeModeLookupKey(value);
+    for (const id of MODE_OPTION_IDS) {
+        if (MODE_ID_ALIASES[id].some(alias => normalizeModeLookupKey(alias) === normalized)) {
+            return id;
+        }
+        if (localeLabels.modeOptions[id].some(label => normalizeModeLookupKey(label) === normalized)) {
+            return id;
+        }
+    }
+    return undefined;
+}
+function normalizeModeLookupKey(value) {
+    return normalizeForLabelMatch(value).replace(/[_-]+/g, " ");
 }
 function requestedModelVersion(args) {
     return args.modelVersion ?? args.version;
@@ -297,12 +479,6 @@ function findUniqueVisibleLabel(labels, wanted) {
     const fuzzy = labels.filter(label => visibleLabelMatches(normalizeLabel(label), normalized));
     return fuzzy.length === 1 ? fuzzy[0] : undefined;
 }
-function visibleLabelMatches(label, wanted) {
-    if (wanted.length <= 3) {
-        return new RegExp(`(^|[^a-z0-9])${escapeRegExp(wanted)}([^a-z0-9]|$)`, "i").test(label);
-    }
-    return label.includes(wanted);
-}
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -311,13 +487,22 @@ function escapeAttributeValue(value) {
 }
 function findAlreadySelectedModes(visibleButtons, requested) {
     return requested
-        .map(label => findUniqueVisibleLabel(visibleButtons, label))
+        .map(request => findUniqueVisibleLabelForRequest(visibleButtons, request))
         .filter((label) => label !== undefined);
 }
+function findUniqueVisibleLabelForRequest(labels, request) {
+    for (const label of request.labels) {
+        const found = findUniqueVisibleLabel(labels, label);
+        if (found !== undefined) {
+            return found;
+        }
+    }
+    return undefined;
+}
 async function selectModelVersion(page, requestedVersion, currentCandidates, timeoutMs) {
     let candidates = await enumerateVisibleMenuItems(page);
-    if (!looksLikeModeMenu(candidates.map(candidate => candidate.label))) {
-        const opened = await waitForModeMenu(page, [requestedVersion], timeoutMs);
+    if (!looksLikeModeMenu(candidates)) {
+        const opened = await waitForModeMenu(page, [{ requested: requestedVersion, labels: [requestedVersion] }], timeoutMs);
         if (opened.opened) {
             await page.waitForTimeout?.(250);
             candidates = await enumerateVisibleMenuItems(page);

package/dist/src/commands/probes.d.ts

@@ -0,0 +1,15 @@
+import { type Deadline } from "./deadline.js";
+export type ProbeResult<T> = {
+    ok: true;
+    value: T;
+    warnings: string[];
+} | {
+    ok: false;
+    timedOut?: boolean;
+    skipped?: boolean;
+    warnings: string[];
+};
+export type ProbeOptions = {
+    timeoutMs: number;
+};
+export declare function createSingleFlightProbe<A, T>(name: string, probe: (arg: A) => Promise<T>): (arg: A, deadline: Deadline, options: ProbeOptions) => Promise<ProbeResult<T>>;

package/dist/src/commands/probes.js

@@ -0,0 +1,64 @@
+import { childTimeoutMs } from "./deadline.js";
+export function createSingleFlightProbe(name, probe) {
+    let inFlight;
+    return async (arg, deadline, options) => {
+        if (inFlight !== undefined) {
+            return {
+                ok: false,
+                skipped: true,
+                warnings: [`Skipped ${name} DOM probe because previous browser-side work is still in flight.`]
+            };
+        }
+        const timeoutMs = childTimeoutMs(deadline, options.timeoutMs);
+        if (timeoutMs <= 0) {
+            return {
+                ok: false,
+                timedOut: true,
+                warnings: [`Skipped ${name} DOM probe because no deadline budget remained.`]
+            };
+        }
+        const current = probe(arg);
+        inFlight = current;
+        current.finally(() => {
+            if (inFlight === current) {
+                inFlight = undefined;
+            }
+        }).catch(() => undefined);
+        let timeout;
+        try {
+            const value = await Promise.race([
+                current,
+                new Promise((_resolve, reject) => {
+                    timeout = setTimeout(() => reject(new ProbeTimeoutError(timeoutMs)), timeoutMs);
+                })
+            ]);
+            return { ok: true, value, warnings: [] };
+        }
+        catch (error) {
+            if (error instanceof ProbeTimeoutError) {
+                return {
+                    ok: false,
+                    timedOut: true,
+                    warnings: [`Timed out waiting ${timeoutMs}ms for ${name} DOM probe; this stopped SDK waiting but did not cancel browser-side work.`]
+                };
+            }
+            return {
+                ok: false,
+                warnings: [`${name} DOM probe failed: ${error instanceof Error ? error.message : String(error)}`]
+            };
+        }
+        finally {
+            if (timeout !== undefined) {
+                clearTimeout(timeout);
+            }
+        }
+    };
+}
+class ProbeTimeoutError extends Error {
+    timeoutMs;
+    constructor(timeoutMs) {
+        super(`Probe timed out after ${timeoutMs}ms.`);
+        this.timeoutMs = timeoutMs;
+        this.name = "ProbeTimeoutError";
+    }
+}

package/dist/src/commands/registry.js

@@ -83,6 +83,7 @@ const descriptors = [
     primitive("projects.sources.add", "Append explicit local files to a visible ChatGPT Project Sources list after confirmMutation: true.", 180000),
     primitive("response.copy", "Click Copy response and return clipboard Markdown, with DOM fallback.", 5000),
     primitive("modes.set", "Select a visible model, intelligence, effort, or nested model-version candidate when unambiguous.", 30000),
+    primitive("modes.get", "Read the mode labels shown on the visible composer controls without changing them.", 30000),
     primitive("tools.select", "Select a visible ChatGPT tool when unambiguous.", 30000)
 ];
 export function commandDescriptors() {
@@ -232,6 +233,14 @@ function reportArgs(name) {
     return { result: "CommandResult to persist", destDir: "optional report directory" };
 }
 function primitiveArgs(name) {
+    if (name === "messages.wait")
+        return {
+            timeoutMs: "optional wait timeout",
+            stableMs: "optional stability window before completion",
+            pollMs: "optional polling interval",
+            mode: "normal or deep_research",
+            responseContent: "include for current behavior, metadata to omit assistant text and return chars/hash only"
+        };
     if (name === "messages.readLatest")
         return { role: "assistant or user", format: "markdown, normalized_text, visible_text, html, blocks, or all" };
     if (name === "artifacts.listLatest")
@@ -245,7 +254,18 @@ function primitiveArgs(name) {
     if (name.startsWith("threads.search"))
         return { query: "history search query" };
     if (name === "files.preflight")
-        return { paths: "absolute local file paths", maxBytesPerFile: "optional local per-file byte limit", maxTotalBytes: "optional local total byte limit" };
+        return {
+            paths: "absolute local file paths",
+            maxBytesPerFile: "optional local per-file byte limit",
+            maxTotalBytes: "optional local total byte limit",
+            includeHashes: "optional SHA-256 metadata for diagnostics; file contents are not returned"
+        };
+    if (name === "files.attach")
+        return {
+            paths: "absolute local file paths",
+            includeDiagnostics: "optional preflight and browser input file-size metadata",
+            includeHashes: "optional SHA-256 metadata inside diagnostics; file contents are not returned"
+        };
     if (name.startsWith("files.attach"))
         return { paths: "absolute local file paths" };
     if (name === "projects.sources.list")
@@ -264,6 +284,11 @@ function primitiveArgs(name) {
             timeoutMs: "optional timeout for opening and selecting the visible mode menu"
         };
     }
+    if (name === "modes.get") {
+        return {
+            timeoutMs: "optional timeout for attaching to the ChatGPT page"
+        };
+    }
     return {};
 }
 function primitiveExamples(name) {
@@ -275,9 +300,16 @@ function primitiveExamples(name) {
             `await chatgpt.askWithFiles({ mode: { model: "Pro" }, files: ["/absolute/host/path.jpg"], prompt: "Describe this image.", wait: true });`
         ];
     }
+    if (name === "modes.get") {
+        return [
+            `await chatgpt.modes.get();`,
+            `// Verify an expensive Pro consult before submitting: const current = await chatgpt.modes.get();`
+        ];
+    }
     if (name === "files.preflight") {
         return [
-            `await chatgpt.files.preflight({ paths: ["/absolute/host/path.md"] });`
+            `await chatgpt.files.preflight({ paths: ["/absolute/host/path.md"] });`,
+            `await chatgpt.files.preflight({ paths: ["/absolute/host/path.md"], includeHashes: true });`
         ];
     }
     if (name === "files.attach") {

package/dist/src/commands/reports.js

@@ -23,7 +23,7 @@ export async function createRunReport(env, result, options = {}) {
         }, options);
         const report = {
             schemaVersion: 1,
-            createdAt: new Date().toISOString(),
+            createdAt,
             includeContent,
             summary,
             steps: result.steps?.map(step => ({

package/dist/src/commands/threads.js

@@ -1,10 +1,10 @@
 import { parseConversationId, readPageState } from "../browser/page-state.js";
 import { resultError, resultOk } from "../errors.js";
-import { countPageMessages, readLatestMessageText } from "../dom/messages.js";
 import { requiredLocator, searchChatsButton, searchChatsInput, newChatButton } from "../dom/selectors.js";
 import { anyLabelPattern, localeLabels } from "../dom/locale-labels.js";
 import { normalizeWhitespace, stripTags } from "../dom/visible-text.js";
 import { contextFromPage } from "./context.js";
+import { ensureConversationTarget } from "./conversation.js";
 import { bootstrap } from "./session.js";
 const CHATGPT_HOME = "https://chatgpt.com/";
 export function extractThreadSearchResultsFromHtml(html) {
@@ -100,13 +100,7 @@ export async function openThread(env, args, previousResults) {
                 context: await contextFromPage(page)
             };
         }
-        if (target.href !== undefined && target.href.startsWith("/")) {
-            await page.goto?.(new URL(target.href, CHATGPT_HOME).toString(), { waitUntil: "domcontentloaded", timeout: args.timeoutMs ?? 30000 });
-        }
-        else {
-            await page.goto?.(target.href ?? target.url, { waitUntil: "domcontentloaded", timeout: args.timeoutMs ?? 30000 });
-        }
-        await waitForThreadHydrated(page, args.timeoutMs ?? 30000, parseConversationId(target.url));
+        await ensureConversationTarget(page, target, { timeoutMs: args.timeoutMs ?? 30000 });
         const state = await readPageState(page);
         return resultOk(openThreadData(state.url, state.conversationId, state.title ?? target.title), await contextFromPage(page));
     }
@@ -283,19 +277,3 @@ function filterResultsByQuery(results, query) {
         return haystack.includes(wanted) || wanted.includes(normalizeForMatch(result.title));
     });
 }
-async function waitForThreadHydrated(page, timeoutMs, expectedConversationId) {
-    const started = Date.now();
-    await page.waitForTimeout?.(1000);
-    while (Date.now() - started < timeoutMs) {
-        const url = typeof page.url === "function" ? await Promise.resolve(page.url()).catch(() => "") : "";
-        const urlMatches = expectedConversationId === undefined || url.includes(expectedConversationId);
-        const count = await countPageMessages(page).catch(() => 0);
-        const latestAssistantText = await readLatestMessageText(page, "assistant").catch(() => undefined);
-        const title = typeof page.title === "function" ? await page.title().catch(() => "") : "";
-        if (urlMatches && ((latestAssistantText?.trim().length ?? 0) > 0 || (count > 0 && title.length > 0 && title !== "ChatGPT"))) {
-            await page.waitForTimeout?.(250);
-            return;
-        }
-        await page.waitForTimeout?.(500);
-    }
-}

package/dist/src/dom/generation-state.d.ts

@@ -4,5 +4,12 @@ export type AssistantGenerationState = {
     stopped: boolean;
     signals: string[];
 };
+/**
+ * Neutral fallback used when generation state cannot be inspected.
+ *
+ * This means "no active/stopped signal observed"; it is not evidence that a
+ * response is complete.
+ */
+export declare const EMPTY_GENERATION_STATE: AssistantGenerationState;
 export declare function readAssistantGenerationState(page: PageLike): Promise<AssistantGenerationState>;
 export declare function latestAssistantTurnHasResponseActions(page: PageLike): Promise<boolean>;

package/dist/src/dom/generation-state.js

@@ -1,6 +1,12 @@
 import { copyResponseButtons } from "./selectors.js";
 import { localeLabels } from "./locale-labels.js";
-const EMPTY_GENERATION_STATE = {
+/**
+ * Neutral fallback used when generation state cannot be inspected.
+ *
+ * This means "no active/stopped signal observed"; it is not evidence that a
+ * response is complete.
+ */
+export const EMPTY_GENERATION_STATE = {
     active: false,
     stopped: false,
     signals: []

package/dist/src/dom/label-match.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeForLabelMatch(text: string): string;
+export declare function visibleLabelMatches(label: string, wanted: string): boolean;
+export declare function isShortLatinToken(value: string): boolean;

package/dist/src/dom/label-match.js

@@ -0,0 +1,25 @@
+import { normalizeWhitespace } from "./visible-text.js";
+export function normalizeForLabelMatch(text) {
+    return normalizeWhitespace(text.normalize("NFKC")).toLocaleLowerCase();
+}
+export function visibleLabelMatches(label, wanted) {
+    const normalizedLabel = normalizeForLabelMatch(label);
+    const normalizedWanted = normalizeForLabelMatch(wanted);
+    if (normalizedWanted.length === 0) {
+        return false;
+    }
+    if (normalizedLabel === normalizedWanted) {
+        return true;
+    }
+    if (isShortLatinToken(normalizedWanted)) {
+        return new RegExp(`(^|[^\\p{L}\\p{N}])${escapeRegExp(normalizedWanted)}([^\\p{L}\\p{N}]|$)`, "iu")
+            .test(normalizedLabel);
+    }
+    return normalizedLabel.includes(normalizedWanted);
+}
+export function isShortLatinToken(value) {
+    return value.length <= 3 && /^[a-z0-9]+$/i.test(value);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/src/dom/locale/am.d.ts

@@ -17,6 +17,12 @@ export declare const am: {
     addPhotosFilesMenuItem: string[];
     copyResponse: string[];
     modeLabels: string[];
+    modeOptions: {
+        instant: string[];
+        medium: string[];
+        high: string[];
+        extraHigh: string[];
+    };
     modeOpenerExtra: string[];
     tools: {
         web_search: string[];

package/dist/src/dom/locale/am.js

@@ -17,6 +17,12 @@ export const am = {
     addPhotosFilesMenuItem: ["ፎቶዎችን እና ፋይሎችን ያክሉ"],
     copyResponse: ["ምላሹን ይቅዱ"],
     modeLabels: ["ፈጣን", "መካከለኛ", "ከፍተኛ", "እጅግ ከፍተኛ"],
+    modeOptions: {
+        instant: ["ፈጣን"],
+        medium: ["መካከለኛ"],
+        high: ["ከፍተኛ"],
+        extraHigh: ["እጅግ ከፍተኛ"],
+    },
     modeOpenerExtra: ["ያዋቅሩ"],
     tools: {
         web_search: ["የድር ፍለጋ"],

package/dist/src/dom/locale/ar.d.ts

@@ -17,6 +17,13 @@ export declare const ar: {
     addPhotosFilesMenuItem: string[];
     copyResponse: string[];
     modeLabels: string[];
+    modeOptions: {
+        instant: string[];
+        medium: string[];
+        high: string[];
+        extraHigh: string[];
+        pro: string[];
+    };
     modeOpenerExtra: string[];
     tools: {
         web_search: string[];