explorbot 0.4.9 → 0.5.0

package/dist/src/ai/provider.js

@@ -3,7 +3,7 @@ import { LangfuseSpanProcessor } from '@langfuse/otel';
 import { NodeSDK } from '@opentelemetry/sdk-node';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import dedent from 'dedent';
-import { APICallError, generateObject, generateText, isStepCount, registerTelemetry, tool } from 'ai';
+import { APICallError, NoObjectGeneratedError, asSchema, extractJsonMiddleware, generateObject, generateText, isStepCount, parsePartialJson, registerTelemetry, tool, wrapLanguageModel } from 'ai';
 import { z } from 'zod';
 import { clearActivity, setActivity } from "../activity.js";
 import { configuredModels, modelName as getModelName } from '../config.js';
@@ -51,12 +51,12 @@ const CONTEXT_LENGTH_PATTERNS = ['reduce the length', 'context length', 'maximum
 function extractCachedTokens(usage) {
     return usage?.inputTokenDetails?.cacheReadTokens ?? 0;
 }
-function abortAfterIdle(ms, cancel, controller) {
+function abortAfterIdle(ms, cancel, controller, busy) {
     return new Promise((_, reject) => {
         const tick = () => {
             if (cancel.cancelled)
                 return;
-            if (executionController.isAwaitingInput()) {
+            if (executionController.isAwaitingInput() || busy.tools > 0) {
                 setTimeout(tick, ms);
                 return;
             }
@@ -78,7 +78,7 @@ export class Provider {
     otelSdk = null;
     defaultRetryOptions = {
         maxAttempts: 3,
-        baseDelay: 10,
+        baseDelay: 1000,
         maxDelay: 10000,
         retryCondition: (error) => {
             return ((error.name === 'AI_APICallError' ||
@@ -231,12 +231,12 @@ export class Provider {
             cached: extractCachedTokens(usage),
         });
     }
-    async raceWithIdleTimeout(fn, timeoutMs) {
+    async raceWithIdleTimeout(fn, timeoutMs, busy = { tools: 0 }) {
         const cancel = { cancelled: false };
         const controller = new AbortController();
         const combinedSignal = combinedAbortSignal(controller);
         try {
-            return await Promise.race([fn(combinedSignal), abortAfterIdle(timeoutMs, cancel, controller)]);
+            return await Promise.race([fn(combinedSignal), abortAfterIdle(timeoutMs, cancel, controller, busy)]);
         }
         finally {
             cancel.cancelled = true;
@@ -249,6 +249,23 @@ export class Provider {
         tag('warning').log('Context length exceeded, retrying with reduced messages...');
         return retry(reduced.messages, { ...options, _contextRetryLevel: reduced.nextLevel });
     }
+    async recoverWithPlainJson(messages, schema, model, options) {
+        const target = asSchema(schema);
+        tag('warning').log(`${getModelName(model)} returned no structured output, asking for plain JSON instead`);
+        const instruction = dedent `
+      Respond with a single JSON object that matches this JSON Schema, and nothing else:
+      ${JSON.stringify(await target.jsonSchema)}
+    `;
+        const response = await this.chat([...messages, { role: 'user', content: instruction }], wrapLanguageModel({ model, middleware: extractJsonMiddleware() }), options);
+        const parsed = await parsePartialJson(response.text);
+        if (parsed.state !== 'successful-parse')
+            throw new AiError('No object generated: plain JSON fallback returned no parsable JSON');
+        const validated = await target.validate?.(parsed.value);
+        if (validated && !validated.success)
+            throw new AiError(`No object generated: plain JSON fallback did not match the schema: ${validated.error.message}`);
+        responseLog(parsed.value);
+        return { ...response, object: validated?.value ?? parsed.value };
+    }
     initLangfuse() {
         const { enabled, publicKey, secretKey, baseUrl } = this.config.langfuse || {};
         if (!enabled || !publicKey || !secretKey) {
@@ -369,6 +386,8 @@ export class Provider {
     }
     async generateWithTools(messages, model, tools, options = {}) {
         const modelName = getModelName(model);
+        const busy = { tools: 0 };
+        tools = withIdleExemption(tools, busy);
         setActivity(`🤖 Asking ${modelName} with dynamic tools`, 'ai');
         promptLog(`Using model: ${modelName}`);
         let toolsWithCommentary = tools;
@@ -394,7 +413,7 @@ export class Provider {
                 const onStepEnd = (step) => {
                     stepMessages.push(...(step.response?.messages || []));
                 };
-                const result = (await this.raceWithIdleTimeout((signal) => generateText({ messages: attemptMessages, ...config, abortSignal: signal, onStepEnd }), config.timeout || 30000).catch((error) => {
+                const result = (await this.raceWithIdleTimeout((signal) => generateText({ messages: attemptMessages, ...config, abortSignal: signal, onStepEnd }), config.timeout || 30000, busy).catch((error) => {
                     if (stepMessages.length > 0) {
                         tag('warning').log(`Keeping ${stepMessages.length} messages from tool steps that already ran before the failure`);
                         executedStepMessages.push(...stepMessages);
@@ -476,6 +495,8 @@ export class Provider {
             if (Provider.isContextLengthError(error)) {
                 return this.recoverFromContextLength(error, messages, options, (m, o) => this.generateObject(m, schema, model, o));
             }
+            if (NoObjectGeneratedError.isInstance(error))
+                return this.recoverWithPlainJson(messages, schema, modelToUse, options);
             throw new AiError(error.message || error.toString());
         }
     }
@@ -695,4 +716,28 @@ function repairHarmonyChannel({ toolCall, tools }) {
     tag('warning').log(`Repaired tool name '${toolCall.toolName}' → 'commentary'`);
     return { ...toolCall, toolName: NARRATION_TOOL, input };
 }
+function withIdleExemption(tools, busy) {
+    if (!tools)
+        return tools;
+    const wrapped = {};
+    for (const [name, definition] of Object.entries(tools)) {
+        if (typeof definition?.execute !== 'function') {
+            wrapped[name] = definition;
+            continue;
+        }
+        wrapped[name] = {
+            ...definition,
+            execute: async (...args) => {
+                busy.tools++;
+                try {
+                    return await definition.execute(...args);
+                }
+                finally {
+                    busy.tools--;
+                }
+            },
+        };
+    }
+    return wrapped;
+}
 export { AiError, Provider as AIProvider };

package/dist/src/ai/rerunner.js

@@ -18,6 +18,7 @@ import { formatHeadings } from "../utils/context-formatter.js";
 import { createDebug, tag } from "../utils/logger.js";
 import { loop } from "../utils/loop.js";
 import { RulesLoader } from "../utils/rules-loader.js";
+import { isInternalStep } from "../utils/step-analyzer.js";
 import { toolExecutionLabel } from "./conversation.js";
 import { actionRule, locatorRule, sectionContextRule } from "./rules.js";
 import { TaskAgent } from "./task-agent.js";
@@ -70,6 +71,8 @@ export class Rerunner extends TaskAgent {
         const onStepStarted = (step) => {
             if (!step.toCode)
                 return;
+            if (isInternalStep(step))
+                return;
             const code = highlight(step.toCode(), { language: 'javascript' });
             console.log(chalk.dim(`    ${code}`));
         };
@@ -77,12 +80,16 @@ export class Rerunner extends TaskAgent {
             const task = this.getCurrentTask(testMap);
             if (!task || !step.toCode)
                 return;
+            if (isInternalStep(step))
+                return;
             task.addStep(step.toCode(), step.duration, 'passed');
         };
         const onStepFailed = (step, error) => {
             const task = this.getCurrentTask(testMap);
             if (!task || !step.toCode)
                 return;
+            if (isInternalStep(step))
+                return;
             task.addStep(step.toCode(), step.duration, 'failed', error?.message);
             console.log(chalk.red(`    ${figureSet.cross} ${step.toCode()} — ${error?.message || 'failed'}`));
         };

package/dist/src/ai/researcher/deep-analysis.js

@@ -94,7 +94,7 @@ export function WithDeepAnalysis(Base) {
             let updated;
             if (extQuery.count() > 0) {
                 const existing = extQuery.text().trimEnd();
-                updated = extQuery.replace(`${existing}\n\n${sectionMarkdown}\n`);
+                updated = extQuery.replace(`${existing}\n\n${sectionMarkdown}\n`).toString();
             }
             else {
                 updated = `${cached.trimEnd()}\n\n# Extended Research\n\n${sectionMarkdown}\n`;
@@ -481,7 +481,7 @@ export function WithDeepAnalysis(Base) {
                 heading = mdq(sectionMarkdown).query('h2[0]');
             if (heading.count() === 0)
                 return sectionMarkdown;
-            return heading.replace(`${heading.text().trimEnd()}\n\n> Container: '${containerCss}'\n\n`);
+            return heading.replace(`${heading.text().trimEnd()}\n\n> Container: '${containerCss}'\n\n`).toString();
         }
         _deduplicateExpandedSections(sections) {
             const seen = new Set();

package/dist/src/ai/researcher/locators.js

@@ -281,10 +281,10 @@ export function WithLocators(Base) {
             if (sectionQuery.count() === 0)
                 sectionQuery = mdq(result.text).query(`section3(~"${escaped}")`);
             if (newCss) {
-                result.text = sectionQuery.query('blockquote[0]').setKeyValue('Container', `'${newCss}'`);
+                result.text = sectionQuery.query('blockquote[0]').setKeyValue('Container', `'${newCss}'`).toString();
             }
             else {
-                result.text = sectionQuery.query('blockquote[0]').replace('');
+                result.text = sectionQuery.query('blockquote[0]').replace('').toString();
                 result.text = result.text.replace(`${FOCUSED_MARKER}\n`, '');
             }
             for (const loc of result.locators) {

package/dist/src/ai/researcher/pagination.js

@@ -56,7 +56,7 @@ export function WithPagination(Base) {
                 sectionQuery = mdq(result.text).query(`section3(~"${escaped}")`);
             if (sectionQuery.count() === 0)
                 return;
-            result.text = sectionQuery.query('blockquote[0]').setKeyValue('Pagination', strategy);
+            result.text = sectionQuery.query('blockquote[0]').setKeyValue('Pagination', strategy).toString();
         }
     };
 }

package/dist/src/ai/researcher/research-result.js

@@ -50,10 +50,10 @@ export class ResearchResult {
         let sectionQuery = mdq(this.text).query(`section2(~"${escaped}")`);
         if (sectionQuery.count() === 0)
             sectionQuery = mdq(this.text).query(`section3(~"${escaped}")`);
-        const updated = sectionQuery.query('table').replace(`${newTable.trimEnd()}\n`);
+        const updated = sectionQuery.query('table').replace(`${newTable.trimEnd()}\n`).toString();
         if (updated === this.text)
             return;
-        section.rawMarkdown = mdq(section.rawMarkdown).query('table').replace(`${newTable.trimEnd()}\n`);
+        section.rawMarkdown = mdq(section.rawMarkdown).query('table').replace(`${newTable.trimEnd()}\n`).toString();
         this.text = updated;
     }
     cleanup() {

package/dist/src/ai/researcher.js

@@ -261,7 +261,7 @@ export class Researcher extends ResearcherBase {
             if (stateHash) {
                 researchFile = saveResearch(researchState, result.text, combinedHtml);
             }
-            const summaryText = mdq(result.text).query('section2(/^summary/)').query('paragraph[0]').text().trim();
+            const summaryText = mdq(result.text).query('section2(/^summary/i)').query('paragraph[0]').text().trim();
             const summaryLine = summaryText.split('\n')[0]?.trim().slice(0, 200);
             if (summaryLine)
                 this.experienceTracker.updateSummary(this.actionResult, summaryLine);

package/dist/src/ai/task-agent.d.ts

@@ -7,6 +7,7 @@ import type { StateManager } from '../state-manager.js';
 import { HooksRunner } from '../utils/hooks-runner.js';
 import type { AgentDeps, ToolDeps } from './agent.js';
 import { Historian } from './historian.js';
+import type { Judge } from './judge.js';
 import type { Navigator } from './navigator.js';
 import type { Provider } from './provider.js';
 import { Quartermaster } from './quartermaster.js';
@@ -17,6 +18,7 @@ export declare abstract class TaskAgent {
     config: ExplorbotConfig;
     stateManager: StateManager;
     knowledgeTracker: KnowledgeTracker;
+    judge?: Judge;
     hooksRunner: HooksRunner;
     consecutiveFailures: number;
     consecutiveEmptyResults: number;

package/dist/src/ai/task-agent.js

@@ -16,6 +16,7 @@ export class TaskAgent {
     config;
     stateManager;
     knowledgeTracker;
+    judge;
     hooksRunner;
     consecutiveFailures = 0;
     consecutiveEmptyResults = 0;
@@ -31,6 +32,7 @@ export class TaskAgent {
         this.config = deps.config;
         this.stateManager = deps.stateManager;
         this.knowledgeTracker = deps.knowledgeTracker;
+        this.judge = deps.judge;
         this.hooksRunner = new HooksRunner(deps.explorer, deps.config);
     }
     setHistorian(historian) {
@@ -40,7 +42,7 @@ export class TaskAgent {
         this._quartermaster = quartermaster;
     }
     get toolDeps() {
-        return { explorer: this.explorer, stateManager: this.stateManager, ai: this.provider };
+        return { explorer: this.explorer, stateManager: this.stateManager, ai: this.provider, judge: this.judge };
     }
     getExperienceTracker() {
         return this.stateManager.getExperienceTracker();

package/dist/src/ai/tester.js

@@ -112,8 +112,8 @@ export class Tester extends TaskAgent {
         let initialState = ActionResult.fromState(state);
         const currentUrl = state.fullUrl || state.url;
         let startOnCurrentPage = opts.startOnCurrentPage;
-        if (isErrorPage(initialState) && !startOnCurrentPage && task.startUrl && normalizeUrl(currentUrl) !== normalizeUrl(task.startUrl)) {
-            debugLog(`Recovering from error page at ${currentUrl} by navigating to ${task.startUrl}`);
+        if (!startOnCurrentPage && task.startUrl && normalizeUrl(currentUrl) !== normalizeUrl(task.startUrl)) {
+            debugLog(`Opening test start URL ${task.startUrl} before building context (was at ${currentUrl})`);
             try {
                 await this.explorer.visit(task.startUrl);
                 state = this.stateManager.getCurrentState();
@@ -123,7 +123,7 @@ export class Tester extends TaskAgent {
                 startOnCurrentPage = true;
             }
             catch (error) {
-                debugLog(`Could not recover from error page: ${compactErrorMessage(error)}`);
+                debugLog(`Could not open test start URL: ${compactErrorMessage(error)}`);
             }
         }
         if (isErrorPage(initialState)) {
@@ -135,13 +135,6 @@ export class Tester extends TaskAgent {
         const conversation = this.provider.startConversation(this.getSystemMessage(), 'tester');
         conversation.markLastMessageCacheable();
         this.currentConversation = conversation;
-        const scenarioBlock = this.buildScenarioBlock(task, initialState);
-        conversation.addUserText(scenarioBlock);
-        conversation.markLastMessageCacheable();
-        conversation.protectPrefix(conversation.messages.length);
-        const pageContext = await this.reinjectContextIfNeeded(1, initialState);
-        if (pageContext)
-            conversation.addUserText(pageContext);
         return await Observability.run(`test: ${task.scenario}`, {
             sessionId: task.sessionName,
             tags: ['tester'],
@@ -154,16 +147,15 @@ export class Tester extends TaskAgent {
     }
     async runTestSession(task, initialState, conversation, handlers, opts) {
         const { offFailedRequest } = handlers;
+        let plan = '';
         if (this.pilot) {
             try {
-                const plan = await this.pilot.planTest(task, initialState);
+                await this.researcher.research(initialState).catch(this.skipResearch);
+                plan = await this.pilot.planTest(task, initialState);
                 if (task.hasFinished) {
                     offFailedRequest?.();
                     return { success: task.isSuccessful };
                 }
-                if (plan) {
-                    conversation.addUserText(`Pilot's test plan:\n${plan}\n\nFollow this plan while executing the test.`);
-                }
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
@@ -183,7 +175,7 @@ export class Tester extends TaskAgent {
         }
         if (opts.startOnCurrentPage)
             debugLog(`Starting on the page already open at ${task.startUrl}`);
-        if (!opts.startOnCurrentPage) {
+        if (!opts.startOnCurrentPage || task.preparedData.length > 0) {
             debugLog(`Navigating to ${task.startUrl}`);
             try {
                 await this.explorer.visit(task.startUrl);
@@ -208,6 +200,15 @@ export class Tester extends TaskAgent {
         }
         const currentUrl = startState?.url || task.startUrl || '';
         await this.hooksRunner.runBeforeHook('tester', currentUrl);
+        const testerState = this.getCurrentState();
+        conversation.addUserText(this.buildScenarioBlock(task, testerState));
+        conversation.markLastMessageCacheable();
+        conversation.protectPrefix(conversation.messages.length);
+        const pageContext = await this.reinjectContextIfNeeded(1, testerState);
+        if (pageContext)
+            conversation.addUserText(pageContext);
+        if (plan)
+            conversation.addUserText(`Pilot's test plan:\n${plan}\n\nFollow this plan while executing the test.`);
         const offStateChange = this.stateManager.onStateChange((event) => {
             if (task.hasFinished)
                 return;
@@ -836,6 +837,9 @@ export class Tester extends TaskAgent {
     `;
     }
     buildDeletionScope(task) {
+        if (task.preparedData.length > 0) {
+            return `When deleting items, ONLY delete the data prepared for this test: ${task.preparedData.join('; ')}.`;
+        }
         const deletableItems = this.getDeletableSessionNames(task);
         if (deletableItems.length > 0) {
             return `When deleting items, ONLY delete items whose title contains one of these session names: ${deletableItems.join(', ')}. These were created by previous tests.`;

package/dist/src/ai/tools.d.ts

@@ -3,6 +3,7 @@ import type { ExecutedStep } from '../action.js';
 import { type ExperienceTracker } from '../experience-tracker.js';
 import { type Task } from '../test-plan.js';
 import type { ToolDeps } from './agent.js';
+import { type Judge } from './judge.js';
 import { Navigator } from './navigator.js';
 import { Researcher } from './researcher.js';
 interface AgentToolDeps extends ToolDeps {
@@ -12,7 +13,7 @@ interface AgentToolDeps extends ToolDeps {
     withExperience?: boolean;
 }
 export declare const ASSERTION_TOOLS: readonly ["verify"];
-export declare function createCodeceptJSTools({ explorer, stateManager }: ToolDeps, task: Task): {
+export declare function createCodeceptJSTools({ explorer, stateManager, judge }: ToolDeps, task: Task): {
     click: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
         commands: any;
         explanation: any;
@@ -55,7 +56,7 @@ export declare function createLearnExperienceTool({ getExperienceTracker, getSta
 } | {
     error: string;
 }, import("@ai-sdk/provider-utils").Context>>;
-export declare function createAgentTools({ explorer, stateManager, ai, researcher, navigator, supervisor, withExperience }: AgentToolDeps): any;
+export declare function createAgentTools({ explorer, stateManager, ai, judge, researcher, navigator, supervisor, withExperience }: AgentToolDeps): any;
 export declare function commitNote(activeNote: any, result: TestResult, toolResult: any, action: any): Promise<void>;
 export declare function successToolResult(action: string, data?: Record<string, any>, source?: {
     playwrightGroupId?: string | null;
@@ -64,7 +65,7 @@ export declare function successToolResult(action: string, data?: Record<string,
 export declare function isMajorPageChange(pageDiff: PageDiff): boolean;
 export declare function hasFailedRequest(pageDiff: PageDiff): boolean;
 export declare function formatExecutedSteps(steps: ExecutedStep[], requestedCount?: number): string;
-export declare function failedToolResult(action: string, message: string, data?: Record<string, any>, error?: Error | null): Promise<Record<string, any>>;
+export declare function failedToolResult(action: string, message: string, data?: Record<string, any>, error?: Error | null, judge?: Judge, intent?: string): Promise<Record<string, any>>;
 export declare function withdrawVisionTools(tools: Record<string, any>): void;
 export declare function clickFailureSuggestion(attempts: Array<{
     error?: string;

package/dist/src/ai/tools.js

@@ -13,11 +13,13 @@ import { createDebug, tag } from '../utils/logger.js';
 import { pause } from '../utils/loop.js';
 import { compactErrorMessage, normalizeInlineText, truncate } from "../utils/strings.js";
 import { WebElement } from "../utils/web-element.js";
+import { createJudgeTool } from "./judge-tool.js";
+import { JUDGE_PAGE_CAP, UNDECIDED } from "./judge.js";
 import { sectionContextRule } from "./rules.js";
 import { isInteractive } from "./task-agent.js";
 const debugLog = createDebug('explorbot:tools');
 export const ASSERTION_TOOLS = ['verify'];
-export function createCodeceptJSTools({ explorer, stateManager }, task) {
+export function createCodeceptJSTools({ explorer, stateManager, judge }, task) {
     return {
         click: tool({
             description: dedent `
@@ -125,7 +127,7 @@ export function createCodeceptJSTools({ explorer, stateManager }, task) {
                     ...toolResult,
                     attempts,
                     suggestion,
-                }, ambiguityError || action.lastError);
+                }, ambiguityError || action.lastError, judge, explanation);
             },
         }),
         hover: tool({
@@ -189,7 +191,7 @@ export function createCodeceptJSTools({ explorer, stateManager }, task) {
                     ...toolResult,
                     attempts,
                     suggestion: 'Use xpathCheck() to locate the row/card/tree node, or visualClick() if the hover target is only visually identifiable.',
-                }, action.lastError);
+                }, action.lastError, judge, explanation);
             },
         }),
         pressKey: tool({
@@ -312,7 +314,7 @@ export function createCodeceptJSTools({ explorer, stateManager }, task) {
         - Performing multiple form actions in a single batch
         - Complex interactions requiring sequential commands
         - Reaching items further down a list (I.scrollTo)
-        - Reloading the page to prove a change outlived it (I.reloadPage)
+        - Reloading the page to prove a change outlived it (I.refreshPage)
 
         Example - filling a form with context (PREFERRED):
         I.fillField('Username', 'John', '.login-form')
@@ -363,7 +365,7 @@ export function createCodeceptJSTools({ explorer, stateManager }, task) {
                             code: codeBlock,
                             attempts: action.executedSteps,
                             suggestion: formSuggestion,
-                        }, action.lastError);
+                        }, action.lastError, judge, explanation);
                     }
                     if (!hasObservablePageChange(toolResult)) {
                         activeNote.commit(TestResult.FAILED);
@@ -498,7 +500,7 @@ export function createLearnExperienceTool({ getExperienceTracker, getState }) {
         },
     });
 }
-export function createAgentTools({ explorer, stateManager, ai, researcher, navigator, supervisor, withExperience }) {
+export function createAgentTools({ explorer, stateManager, ai, judge, researcher, navigator, supervisor, withExperience }) {
     const tools = {
         see: tool({
             description: dedent `
@@ -619,6 +621,12 @@ export function createAgentTools({ explorer, stateManager, ai, researcher, navig
                         }, { assertionSteps: result.assertionSteps });
                     }
                     if (result.inexpressible) {
+                        if (result.judged?.approved) {
+                            return failedToolResult('verify', `No assertion could express this claim, but the page appears to confirm it: ${assertion}`, {
+                                inexpressible: true,
+                                suggestion: 'This is a judgement about the page, not an assertion that ran in the browser — a hint, not proof. Restate the claim in terms of what is visible or of a control state to get a real assertion.',
+                            });
+                        }
                         return failedToolResult('verify', `No assertion could express this claim: ${assertion}`, {
                             inexpressible: true,
                             suggestion: 'This is not evidence the page is wrong — the claim could not be turned into an assertion. Restate it in terms of what is visible or of a control state, or check it with see().',
@@ -994,6 +1002,19 @@ export function createAgentTools({ explorer, stateManager, ai, researcher, navig
             },
         });
     }
+    const buildJudgeState = async () => {
+        const activeTest = explorer.activeTest;
+        const state = stateManager.getCurrentState();
+        const result = state ? ActionResult.fromState(state) : null;
+        return {
+            task: activeTest?.scenario || '',
+            page: cap(result?.getCompactARIA(), JUDGE_PAGE_CAP),
+            recentActions: Object.values(activeTest?.steps || {})
+                .slice(-JUDGE_RECENT_ACTIONS_LIMIT)
+                .map((step) => step.text),
+        };
+    };
+    Object.assign(tools, createJudgeTool({ explorer, stateManager, ai, judge }, buildJudgeState));
     withdrawVisionTools(tools);
     return tools;
 }
@@ -1003,6 +1024,7 @@ const NAVIGATED_SUGGESTION = 'The action left the page. Elements are never compa
 const ARIA_OUTPUT_CAP = 4000;
 const HTML_OUTPUT_CAP = 6000;
 const ANALYSIS_OUTPUT_CAP = 2000;
+const JUDGE_RECENT_ACTIONS_LIMIT = 8;
 function cap(text, max) {
     if (!text)
         return '';
@@ -1115,7 +1137,7 @@ function hasObservablePageChange(data) {
         return true;
     return Array.isArray(data.pageDiff.htmlParts) && data.pageDiff.htmlParts.length > 0;
 }
-export async function failedToolResult(action, message, data, error) {
+export async function failedToolResult(action, message, data, error, judge, intent) {
     const result = { success: false, action, message, ...data };
     if (data?.pageDiff) {
         result.suggestion = data.suggestion ? `${data.suggestion} ${PAGE_DIFF_SUGGESTION}` : PAGE_DIFF_SUGGESTION;
@@ -1126,6 +1148,12 @@ export async function failedToolResult(action, message, data, error) {
         result.suggestion = getMultipleElementsSuggestion();
         result.multipleElementsDetected = true;
         result.elements = formatElementList(matched);
+        const labels = (matched || []).map((element) => `${element.text || 'no text'} — ${element.html}`);
+        const pick = await judge?.decide('Which listed element does the intent name?', [...labels, UNDECIDED], { intent });
+        if (!pick?.value)
+            return result;
+        const index = labels.indexOf(pick.value) + 1;
+        result.suggestion = `Element ${index} is the one meant. Repeat the action with step.opts({ elementIndex: ${index} }) as the last argument.`;
         return result;
     }
     const notFoundSuggestion = getNotFoundSuggestion(message);

package/dist/src/api/request-result.js

@@ -162,7 +162,8 @@ export class RequestResult {
         if (Array.isArray(data))
             return {};
         const id = data.id ?? data._id ?? data.uuid;
-        const title = data.name ?? data.title ?? data.label;
+        const attributes = data.attributes || {};
+        const title = data.name ?? data.title ?? data.label ?? attributes.name ?? attributes.title ?? attributes.label;
         const result = {};
         if (id !== undefined)
             result.id = id;

package/dist/src/api/xhr-capture.js

@@ -1,3 +1,4 @@
+import { isSameHostFamily } from '../utils/url-matcher.js';
 import { RequestResult, generateRequestId } from "./request-result.js";
 const WRITE_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
 const JSON_CONTENT_TYPES = /application\/json|application\/.*\+json/i;
@@ -33,7 +34,7 @@ export class XhrCapture {
             return;
         const method = request.method();
         const url = request.url();
-        if (!url.startsWith(this.baseOrigin))
+        if (!isSameHostFamily(url, this.baseOrigin))
             return;
         const status = response.status();
         if (status >= 400) {

package/dist/src/command-handler.d.ts

@@ -24,6 +24,7 @@ export interface CommandAutocomplete {
     replaceTo: number;
     visible: boolean;
     argumentHint?: string;
+    completesArgument?: boolean;
 }
 export declare class CommandHandler implements InputManager {
     explorBot: ExplorBot;

package/dist/src/command-handler.js

@@ -207,6 +207,28 @@ export class CommandHandler {
         const parsed = parseCommand(query);
         const exactCommand = parsed ? this.findCommand(parsed.name) : undefined;
         const hasArguments = commandEnd !== -1 && input.slice(commandEnd + 1).trim().length > 0;
+        const argumentHint = !insideCommand && exactCommand && !hasArguments && exactCommand.options.length > 0 ? exactCommand.options.map((option) => option.flags).join(' ') : undefined;
+        if (!insideCommand && exactCommand) {
+            const argumentQuery = input.slice(commandEnd + 1).trim();
+            const argumentEntries = exactCommand
+                .completeArguments()
+                .filter((completion) => completion.value !== argumentQuery)
+                .map((completion) => ({
+                aliases: [],
+                canonical: completion.value,
+                description: '',
+                value: completion.display || completion.value,
+            }));
+            const argumentSuggestions = this.rankSuggestions(argumentQuery, argumentEntries);
+            return {
+                suggestions: argumentSuggestions,
+                replaceFrom: commandEnd + 1,
+                replaceTo: input.length,
+                visible: argumentSuggestions.length > 0,
+                argumentHint,
+                completesArgument: true,
+            };
+        }
         const commandEntries = this.getSlashCommandEntries();
         let suggestions = [];
         if (insideCommand) {
@@ -222,9 +244,8 @@ export class CommandHandler {
                 suggestions = this.rankSuggestions(query, commandEntries);
             }
         }
-        const argumentHint = !insideCommand && exactCommand && !hasArguments && exactCommand.options.length > 0 ? exactCommand.options.map((option) => option.flags).join(' ') : undefined;
         return {
-            suggestions,
+            suggestions: suggestions.map((suggestion) => ({ ...suggestion, value: `${suggestion.value} ` })),
             replaceFrom: 0,
             replaceTo,
             visible: insideCommand && suggestions.length > 0,
@@ -305,7 +326,7 @@ export class CommandHandler {
     rankSuggestions(query, entries) {
         if (!query) {
             return entries.slice(0, 20).map((entry) => ({
-                value: entry.value,
+                value: entry.canonical,
                 display: entry.value,
                 description: entry.description,
                 argumentHint: entry.argumentHint,

package/dist/src/commands/base-command.d.ts

@@ -18,9 +18,14 @@ export declare abstract class BaseCommand<T = ExplorBot> {
     constructor(explorBot: T);
     abstract execute(args: string): Promise<void>;
     matches(commandName: string): boolean;
+    completeArguments(): ArgumentCompletion[];
     printSuggestions(): void;
     parseArgs(args: string): {
         opts: Record<string, string | boolean>;
         args: string[];
     };
 }
+export interface ArgumentCompletion {
+    value: string;
+    display?: string;
+}

package/dist/src/commands/base-command.js

@@ -15,6 +15,9 @@ export class BaseCommand {
     matches(commandName) {
         return this.name === commandName || this.aliases.includes(commandName);
     }
+    completeArguments() {
+        return [];
+    }
     printSuggestions() {
         if (this.suggestions.length === 0)
             return;

package/dist/src/commands/explore-command.d.ts

@@ -1,5 +1,5 @@
 import { type Plan, type Test } from '../test-plan.js';
-import { BaseCommand, type Suggestion } from './base-command.js';
+import { type ArgumentCompletion, BaseCommand, type Suggestion } from './base-command.js';
 export declare const DEADLINE_RESERVE_MS: number;
 export declare const DEADLINE_TEST_ALLOWANCE_MS: number;
 export declare class ExploreCommand extends BaseCommand {
@@ -22,6 +22,7 @@ export declare class ExploreCommand extends BaseCommand {
     priorityFilter?: Set<string>;
     getCurrentPageUrl(): string | undefined;
     execute(args: string): Promise<void>;
+    completeArguments(): ArgumentCompletion[];
     originLabel(test: Test): string;
     printPreview(label: string, tests: Test[]): void;
     runFreshMode(mainUrl: string | undefined, feature: string | undefined, styles?: string[]): Promise<void>;