explorbot 0.1.28 → 0.1.29

package/src/ai/provider.ts

@@ -1,6 +1,7 @@
+import { OpenTelemetry } from '@ai-sdk/otel';
 import { LangfuseSpanProcessor } from '@langfuse/otel';
 import { NodeSDK } from '@opentelemetry/sdk-node';
-import { generateObject, generateText, stepCountIs } from 'ai';
+import { generateObject, generateText, isStepCount, registerTelemetry } from 'ai';
 import type { ModelMessage } from 'ai';
 import { clearActivity, setActivity } from '../activity.ts';
 import type { AIConfig } from '../config.js';
@@ -19,9 +20,11 @@ const responseLog = createDebug('explorbot:provider:in');
 class AiError extends Error {}
 export class ContextLengthError extends Error {}
 
+let telemetryRegistered = false;
+
 function extractCachedTokens(usage: any): number {
   if (!usage) return 0;
-  const direct = usage.cachedInputTokens ?? usage.inputTokenDetails?.cacheReadTokens;
+  const direct = usage.inputTokenDetails?.cacheReadTokens ?? usage.cachedInputTokens;
   if (typeof direct === 'number') return direct;
   const raw = usage.raw;
   const fromRaw = raw?.prompt_tokens_details?.cached_tokens ?? raw?.promptTokensDetails?.cachedTokens;
@@ -86,7 +89,7 @@ export class Provider {
       await generateText({
         model: this.config.model,
         prompt: 'hi',
-        maxTokens: 1,
+        maxOutputTokens: 1,
       });
     } catch (error: any) {
       throw new AiError(`AI connection failed: ${error.message}`);
@@ -110,6 +113,16 @@ export class Provider {
     return this.config.agenticModel || this.config.model;
   }
 
+  getConfiguredModels(): Record<string, string> {
+    const models: Record<string, string> = { model: this.getModelName(this.config.model) };
+    if (this.config.agenticModel) models.agenticModel = this.getModelName(this.config.agenticModel);
+    if (this.config.visionModel) models.visionModel = this.getModelName(this.config.visionModel);
+    for (const [agent, agentConfig] of Object.entries(this.config.agents || {})) {
+      if (agentConfig?.model) models[agent] = this.getModelName(agentConfig.model);
+    }
+    return models;
+  }
+
   getSystemPromptForAgent(agentName: string, currentUrl?: string): string | undefined {
     const agentConfig = this.config.agents?.[agentName as keyof typeof this.config.agents];
     const parts: string[] = [];
@@ -129,6 +142,12 @@ export class Provider {
     return agentConfig?.providerOptions;
   }
 
+  getReasoningForAgent(agentName?: string): string | undefined {
+    if (!agentName) return undefined;
+    const agentConfig = this.config.agents?.[agentName as keyof typeof this.config.agents];
+    return agentConfig?.reasoning;
+  }
+
   private getRetryOptions(options: any = {}): RetryOptions {
     return {
       ...this.defaultRetryOptions,
@@ -146,6 +165,12 @@ export class Provider {
     };
   }
 
+  private finalizeConfig(config: Record<string, any>, options: any, telemetry: any): void {
+    if (telemetry) config.telemetry = telemetry;
+    const reasoning = this.getReasoningForAgent(options.agentName);
+    if (reasoning) config.reasoning ??= reasoning;
+  }
+
   private initLangfuse() {
     const langfuseConfig = this.config.langfuse;
     const publicKey = langfuseConfig?.publicKey || process.env.LANGFUSE_PUBLIC_KEY;
@@ -167,6 +192,10 @@ export class Provider {
       instrumentations: [],
     });
     void this.otelSdk.start();
+    if (!telemetryRegistered) {
+      registerTelemetry(new OpenTelemetry());
+      telemetryRegistered = true;
+    }
     this.telemetryEnabled = true;
   }
 
@@ -177,20 +206,20 @@ export class Provider {
 
     const runTelemetry = Observability.getTelemetry();
 
-    if (!options.experimental_telemetry) {
-      return runTelemetry || { isEnabled: true };
+    if (!options.telemetry) {
+      return runTelemetry;
     }
 
     if (!runTelemetry) {
-      return options.experimental_telemetry;
+      return options.telemetry;
     }
 
     return {
       ...runTelemetry,
-      ...options.experimental_telemetry,
+      ...options.telemetry,
       metadata: {
         ...runTelemetry.metadata,
-        ...options.experimental_telemetry.metadata,
+        ...options.telemetry.metadata,
       },
     };
   }
@@ -242,15 +271,16 @@ export class Provider {
     const telemetry = this.getTelemetry(options);
     const config = this.mergeProviderOptions(
       {
-        maxTokens: 16384,
+        maxOutputTokens: 16384,
+        allowSystemInMessages: true,
         ...(this.config.config || {}),
         ...options,
-        ...(telemetry ? { experimental_telemetry: telemetry } : {}),
         model,
         abortSignal: executionController.getAbortSignal(),
       },
       options.agentName
     );
+    this.finalizeConfig(config, options, telemetry);
 
     promptLog(messages[messages.length - 1].content);
     try {
@@ -259,7 +289,7 @@ export class Provider {
         if (!result.text) {
           debugLog(result);
           if (result.finishReason === 'length') {
-            throw new ContextLengthError('AI response empty: output truncated at maxTokens. Increase maxTokens in config or use a model with higher output capacity.');
+            throw new ContextLengthError('AI response empty: output truncated at maxTokens. Increase maxOutputTokens in config or use a model with higher output capacity.');
           }
           throw new Error('No response text from AI');
         }
@@ -315,23 +345,24 @@ export class Provider {
     const telemetry = this.getTelemetry(options);
     const maxRoundtrips = options.maxToolRoundtrips ?? 5;
     const extraStop = options.stopWhen;
-    const stopConditions: any[] = [stepCountIs(maxRoundtrips)];
+    const stopConditions: any[] = [isStepCount(maxRoundtrips)];
     if (extraStop) stopConditions.push(extraStop);
     const { stopWhen: _ignoredStopWhen, ...optionsWithoutStop } = options;
     const config = this.mergeProviderOptions(
       {
         tools,
-        maxTokens: 16384,
+        maxOutputTokens: 16384,
         toolChoice: 'auto',
+        allowSystemInMessages: true,
         ...(this.config.config || {}),
         ...optionsWithoutStop,
         stopWhen: stopConditions,
-        ...(telemetry ? { experimental_telemetry: telemetry } : {}),
         model,
         abortSignal: executionController.getAbortSignal(),
       },
       options.agentName
     );
+    this.finalizeConfig(config, options, telemetry);
     try {
       const response = await withRetry(async () => {
         const timeout = config.timeout || 30000;
@@ -346,7 +377,7 @@ export class Provider {
           ])) as any;
           const hasToolCall = (result.toolCalls?.length || 0) > 0;
           if (!result.text && !hasToolCall && result.finishReason === 'length') {
-            throw new ContextLengthError('AI response empty: output truncated at maxTokens. Increase maxTokens in config or use a model with higher output capacity.');
+            throw new ContextLengthError('AI response empty: output truncated at maxTokens. Increase maxOutputTokens in config or use a model with higher output capacity.');
           }
           return result;
         } finally {
@@ -409,14 +440,15 @@ export class Provider {
     const config = this.mergeProviderOptions(
       {
         schema,
+        allowSystemInMessages: true,
         ...(this.config.config || {}),
         ...options,
-        ...(telemetry ? { experimental_telemetry: telemetry } : {}),
         model: modelToUse,
         abortSignal: executionController.getAbortSignal(),
       },
       options.agentName
     );
+    this.finalizeConfig(config, options, telemetry);
 
     try {
       promptLog(messages[messages.length - 1].content);
@@ -617,13 +649,13 @@ export class Provider {
     ];
 
     const telemetry = this.getTelemetry({});
-    const config = {
-      maxTokens: 16384,
+    const config: Record<string, any> = {
+      maxOutputTokens: 16384,
       ...(this.config.config || {}),
-      ...(telemetry ? { experimental_telemetry: telemetry } : {}),
       model: this.config.visionModel,
       abortSignal: executionController.getAbortSignal(),
     };
+    if (telemetry) config.telemetry = telemetry;
 
     try {
       promptLog(`Processing image with prompt: ${prompt}`);

package/src/ai/researcher.ts

@@ -68,6 +68,13 @@ export class Researcher extends ResearcherBase implements Agent {
     this.stateManager = explorer.getStateManager();
     this.experienceTracker = this.stateManager.getExperienceTracker();
     this.hooksRunner = new HooksRunner(explorer, explorer.getConfig());
+
+    const ai = explorer.getConfig().ai;
+    if (ai) {
+      ai.agents ??= {};
+      ai.agents.researcher ??= {};
+      ai.agents.researcher.reasoning ??= 'low';
+    }
   }
 
   protected getNavigator(): Navigator {
@@ -177,7 +184,7 @@ export class Researcher extends ResearcherBase implements Agent {
       } catch (error) {
         if (!(error instanceof ContextLengthError) || retriesLeft <= 0) {
           if (error instanceof ContextLengthError) {
-            tag('warning').log('Output truncated. Try lowering reasoning effort or increasing maxTokens in ai.config.');
+            tag('warning').log('Output truncated. Try lowering reasoning effort or increasing maxOutputTokens in ai.config.');
           }
           throw error;
         }

package/src/ai/rules.ts

@@ -153,6 +153,52 @@ export const protectionRule = dedent`
   </important>
 `;
 
+export const dataProtectionRules = dedent`
+  <data_protection_rules>
+  ${protectionRule}
+
+  If the user request, scenario, focus, or test instructions explicitly prohibit creating,
+  editing, updating, deleting, removing, or otherwise mutating data, do not perform those
+  actions through the UI, API preconditions, cleanup, fallback steps, or Fisherman.
+
+  Do not use Fisherman or API data preparation to bypass a no-mutation, read-only, search,
+  filter, tab, or list-inspection constraint. Use visible existing data when it is available.
+  If no suitable data exists, report the missing precondition instead of creating data.
+
+  Destructive actions are allowed only against disposable data created by the current scenario
+  or prepared for that scenario by Fisherman/API preconditions. Existing application data must
+  remain unchanged.
+  </data_protection_rules>
+`;
+
+export const capabilityGroundingRule = dedent`
+  <capability_grounding>
+  When a scenario depends on a named action, menu item, status, option, workflow, or feature,
+  that capability must be visible or explicitly confirmed in the current research/page context
+  for the same target entity type.
+
+  Do not transfer capabilities between similar entities, rows, lists, detail pages, or menus.
+  Do not replace a requested action with a synonym or related action unless the UI explicitly
+  shows that action for the target entity.
+
+  When an action is described as applying to an item, row, card, record, node, or entity,
+  the target must be grounded as that kind of data entity in the current context. Do not use
+  navigation links, filter tabs, counters, breadcrumbs, headings, toolbar controls, or other
+  page controls as the subject of row/entity actions.
+
+  When a scenario asks to open, view, inspect, or navigate to an entity detail view, success
+  requires evidence of that entity detail context. An active filter, selected tab, visible count,
+  or filtered list is not enough to prove an entity detail view opened.
+
+  Do not rewrite a scenario goal to match a similar outcome that happened accidentally. If the
+  requested entity detail/action/workflow was not achieved, report that mismatch instead of
+  passing the test for a related filter, tab, navigation, or status view.
+
+  If the required capability is not available for the target entity after reasonable discovery,
+  record the missing capability and stop instead of repeatedly trying unrelated locators.
+  </capability_grounding>
+`;
+
 export const focusedElementRule = dedent`
   <focused_element_actions>
   When a text input element is focused (textbox, combobox, contenteditable):

package/src/ai/tester.ts

@@ -25,7 +25,7 @@ import { Navigator } from './navigator.ts';
 import type { Pilot } from './pilot.ts';
 import { Provider } from './provider.ts';
 import { Researcher } from './researcher.ts';
-import { actionRule, focusedElementRule, formRequirementsRule, locatorRule, multipleTabsRule, protectionRule, sectionContextRule } from './rules.ts';
+import { actionRule, capabilityGroundingRule, dataProtectionRules, focusedElementRule, formRequirementsRule, locatorRule, multipleTabsRule, sectionContextRule } from './rules.ts';
 import { TaskAgent } from './task-agent.ts';
 import { createCodeceptJSTools, createSpecialContextTools } from './tools.ts';
 
@@ -43,7 +43,7 @@ const SAMPLE_FILES: Record<string, string> = {
 };
 
 export class Tester extends TaskAgent implements Agent {
-  protected readonly ACTION_TOOLS = ['click', 'pressKey', 'form'];
+  protected readonly ACTION_TOOLS = ['click', 'hover', 'pressKey', 'form'];
   protected readonly SPECIAL_CONTEXT_ACTION_TOOLS = ['exitIframe'];
   emoji = '🧪';
   private explorer: Explorer;
@@ -66,6 +66,8 @@ export class Tester extends TaskAgent implements Agent {
   private hooksRunner: HooksRunner;
   private seenUiMapUrls = new Set<string>();
   private lastAnalyzedStateHash: string | null = null;
+  private stalledIterations = 0;
+  private readonly MAX_STALLED_ITERATIONS = 3;
 
   constructor(explorer: Explorer, provider: Provider, researcher: Researcher, navigator: Navigator, agentTools?: any) {
     super();
@@ -126,6 +128,7 @@ export class Tester extends TaskAgent implements Agent {
     this.pageActionResult = null;
     this.seenUiMapUrls.clear();
     this.lastAnalyzedStateHash = null;
+    this.stalledIterations = 0;
     this.explorer.getStateManager().clearHistory();
     this.resetFailureCount();
     this.pilot?.reset();
@@ -348,6 +351,11 @@ export class Tester extends TaskAgent implements Agent {
               });
           }
 
+          if (this.shouldStopForStalledExecution(task, currentState, result?.toolExecutions || [])) {
+            stop();
+            return;
+          }
+
           if (assertionPerformed) {
             const message = result?.toolExecutions?.find((execution: any) => execution.toolName === 'verify')?.output?.message || '';
             task.addNote(message, wasSuccessful ? TestResult.PASSED : TestResult.FAILED);
@@ -456,6 +464,31 @@ export class Tester extends TaskAgent implements Agent {
     return true;
   }
 
+  private shouldStopForStalledExecution(task: Test, previousState: ActionResult, toolExecutions: any[]): boolean {
+    if (task.hasFinished) return false;
+
+    const currentState = this.getCurrentState();
+    const stateChanged = previousState.url !== currentState.url || previousState.hash !== currentState.hash;
+    const actionTools = [...this.ACTION_TOOLS, ...this.SPECIAL_CONTEXT_ACTION_TOOLS];
+    const hasSuccessfulAction = toolExecutions.some((execution) => execution.wasSuccessful && actionTools.includes(execution.toolName));
+    const hasSuccessfulAssertion = toolExecutions.some((execution) => execution.wasSuccessful && this.ASSERTION_TOOLS.includes(execution.toolName));
+
+    if (stateChanged || hasSuccessfulAction || hasSuccessfulAssertion) {
+      this.stalledIterations = 0;
+      return false;
+    }
+
+    const hasNoBrowserProgress = toolExecutions.length === 0 || toolExecutions.every((execution) => !actionTools.includes(execution.toolName) || !execution.wasSuccessful);
+    if (!hasNoBrowserProgress) return false;
+
+    this.stalledIterations++;
+    if (this.stalledIterations < this.MAX_STALLED_ITERATIONS) return false;
+
+    task.addNote('No browser progress after repeated attempts on unchanged page', TestResult.FAILED);
+    task.finish(TestResult.FAILED);
+    return true;
+  }
+
   private async prepareInstructionsForNextStep(task: Test): Promise<string> {
     let outcomeStatus = dedent`
       <task>
@@ -464,6 +497,8 @@ export class Tester extends TaskAgent implements Agent {
   
       <rules>
       Use tools ${this.ACTION_TOOLS.join(', ')} to interact with the page.
+      Use tool names exactly as listed in this prompt. Do not invent combined tool names, aliases, or names with channel markers such as "commentary".
+      Match each tool input schema exactly. Do not invent parameter names or pass extra fields.
       Do not do unsuccesful clicks again.
       Do not run same tool calls with same parameters again.
       </rules>
@@ -746,6 +781,7 @@ export class Tester extends TaskAgent implements Agent {
     <rules>
     - Refer to UI Map from <page_ui_map> to understand the page structure and its main elements
     - Use only elements that exist in the provided ARIA tree or HTML, <page_aria> and <page_html>
+    - Use tool input schemas exactly as documented. Do not invent parameter names or add fields not listed by the tool schema.
     - Use click() for buttons, links, and clickable elements ONLY - do NOT include I.fillField() or I.type() commands in click() tool
     - click() commands array is for FALLBACK LOCATORS of the SAME element, NOT for clicking different elements in sequence. If you need to click two different elements, make two separate click() calls.
     - Use form() for text input (I.fillField, I.type), dropdown selection (I.selectOption), file uploads (I.attachFile), and multi-step form interactions
@@ -758,6 +794,7 @@ export class Tester extends TaskAgent implements Agent {
     - NEVER call record(status: "success") if your last verify() or see() call FAILED. A failed check means the outcome is NOT confirmed — use record(status: "fail") instead, or retry with a different approach.
     - Use finish() to complete the test, not record(). record() is for intermediate notes.
     - Call finish(verify) when all goals are achieved — provide an assertion to verify
+    - NEVER call finish() with a negative assertion that says the goal did NOT happen. If the goal cannot be achieved after real attempts, record the blocker and call stop().
     - ONLY call stop() if the scenario itself is completely irrelevant to this page and no expectations can be achieved
     - Use reset() ONLY as a last resort when the current page cannot host the scenario. Never reset after a successful flow just because an assertion or milestone did not match — verify differently or record() the finding instead. Reset is destructive and does not undo server-side side effects.
     - Be precise with locators (CSS or XPath)
@@ -771,6 +808,13 @@ export class Tester extends TaskAgent implements Agent {
     - When you interact with form with inputs, ensure that you click corresponding button to save its data
     - Follow <locator_priority> rules when selecting locators for all tools
     - Before retrying your actions check maybe they already achived expected results. Use see() tool for that
+    - If the current URL is already a create/edit/new form and the scenario is about creating/editing that entity, fill and submit that form. Do not click the list-page "New" button again from inside the form.
+    - If the scenario is about search/filter/sort/tabs/list inspection and the current URL is a create/edit/new form, go back or reset to the stable list page before interacting with list controls.
+    - When selecting related entities from a list, do not choose rows/options/cards marked as "0 items", "0 tests", or otherwise empty if the scenario requires selecting real content.
+    - In selection pickers, counters such as "Selected 0", "Matched tests 0", or disabled Save/Apply mean the selection did not register. Choose a non-empty item or change filters before submitting.
+    - A passed form/click command only means the command executed. If a required field remains empty, submit stays disabled, or the expected text is not visible, treat the action as not completed and correct the missing field/state.
+    - For filter/tab scenarios, success requires BOTH: the requested filter/tab is visibly active/selected AND the list content matches that filter. Do not finish from only one of these signals.
+    - Empty-state text such as "No matched items" only proves a filter when the requested filter/tab is active and the empty state belongs to the filtered list.
     - When filling complex form with lot of actions performed, use see() to look which fields were filled and which are not
     - When verify() fails, use see() to visually confirm the result — visual confirmation is equally valid evidence
     - For visual state verification (active tabs, selected items, counts, colors), prefer see() over DOM-based verify()
@@ -799,6 +843,10 @@ export class Tester extends TaskAgent implements Agent {
 
     ${formRequirementsRule}
 
+    ${capabilityGroundingRule}
+
+    ${dataProtectionRules}
+
     ${this.provider.getSystemPromptForAgent('tester', this.explorer.getStateManager().getCurrentState()?.url) || ''}
     `;
   }
@@ -822,10 +870,13 @@ export class Tester extends TaskAgent implements Agent {
       Try to achieve as many goals as possible.
       If goal is not achievable, log that and skip to next one.
       Do not hallucinate that goal was achieved when it was not.
+      If the scenario action could not be completed, do not finish with a verification of the failure state.
       When creating or editing items via form() or type() you should include ${task.sessionName} in the value (if it is not restricted by the application logic)
       Initial page URL: ${actionResult.url}
 
-      ${protectionRule}
+      ${capabilityGroundingRule}
+
+      ${dataProtectionRules}
 
       ${this.buildDeletionScope(task)}
 
@@ -963,12 +1014,13 @@ export class Tester extends TaskAgent implements Agent {
       }),
       stop: tool({
         description: dedent`
-          Stop the current test because the scenario is fundamentally incompatible with the page.
-          Use this ONLY when the scenario cannot be executed on the current page or application.
-          Do NOT use this for failures — use reset() and retry instead.
+          Stop the current test because it cannot be completed in the current session.
+          Use this when the scenario is incompatible, required UI/data is absent, or repeated varied attempts
+          show that automation cannot complete the workflow.
+          Do NOT use this immediately after the first failed action — retry with a materially different approach first.
         `,
         inputSchema: z.object({
-          reason: z.string().describe('Explanation why the scenario is incompatible'),
+          reason: z.string().describe('Explanation why the scenario cannot be completed'),
         }),
         execute: async ({ reason }) => {
           task.addNote(`Stop requested: ${reason}`);
@@ -1003,6 +1055,7 @@ export class Tester extends TaskAgent implements Agent {
           Provide a specific assertion to verify the final state.
           The assertion MUST prove that YOUR ACTIONS changed the page state.
           Do NOT verify something that was already true before you started testing.
+          Do NOT provide an assertion that verifies absence, failure, an empty state, or that the goal did not happen.
 
           Examples of good assertions:
           - "New user 'john@example.com' is visible in the users list"
@@ -1135,12 +1188,26 @@ export class Tester extends TaskAgent implements Agent {
       this.resetFailureCount();
       this.previousUrl = null;
       this.previousStateHash = null;
+      this.stalledIterations = 0;
+    } else if (this.shouldStopAfterStalledLoopError(task)) {
+      return 'stop';
     }
 
     this.currentConversation?.addUserText(result.message);
     return 'continue';
   }
 
+  private shouldStopAfterStalledLoopError(task: Test): boolean {
+    if (task.hasFinished) return false;
+
+    this.stalledIterations++;
+    if (this.stalledIterations < this.MAX_STALLED_ITERATIONS) return false;
+
+    task.addNote('No browser progress after repeated execution errors', TestResult.FAILED);
+    task.finish(TestResult.FAILED);
+    return true;
+  }
+
   private async cleanupStartedTest(task: Test): Promise<void> {
     await this.finishTest(task);
     await this.explorer.stopTest(task, {

package/src/ai/tools.ts

@@ -18,7 +18,7 @@ import { isInteractive } from './task-agent.ts';
 
 const debugLog = createDebug('explorbot:tools');
 
-export const CODECEPT_TOOLS = ['click', 'pressKey', 'form'] as const;
+export const CODECEPT_TOOLS = ['click', 'hover', 'pressKey', 'form'] as const;
 export const ASSERTION_TOOLS = ['verify'] as const;
 
 export function createCodeceptJSTools(explorer: Explorer, task: Task) {
@@ -160,6 +160,84 @@ export function createCodeceptJSTools(explorer: Explorer, task: Task) {
       },
     }),
 
+    hover: tool({
+      description: dedent`
+        Move the mouse cursor to an element to reveal hover-only controls.
+
+        Use this before clicking row actions, icon buttons, menus, or toolbars that appear only
+        when the user hovers a list item, table row, card, or tree node.
+
+        This tool ONLY accepts I.moveCursorTo(locator) commands. It does not click.
+        After hovering, use context(), see(), or click() the revealed control.
+      `,
+      inputSchema: z.object({
+        commands: z.array(z.string()).describe(dedent`
+          FALLBACK LOCATORS for ONE element to hover.
+          Order by reliability:
+          1. I.moveCursorTo(text, container)
+          2. I.moveCursorTo(ARIA, container)
+          3. I.moveCursorTo(CSS, container)
+          4. I.moveCursorTo(CSS) or I.moveCursorTo(XPath)
+        `),
+        explanation: z.string().describe('Why you are hovering this element'),
+      }),
+      execute: async ({ commands: rawCommands, explanation }) => {
+        const activeNote = task.startNote(explanation);
+
+        if (rawCommands.length === 0) {
+          activeNote.commit(TestResult.FAILED);
+          return failedToolResult('hover', 'No commands provided');
+        }
+
+        const invalidCommands = rawCommands.map((cmd) => cmd.trim()).filter((cmd) => cmd.startsWith('I.') && !cmd.startsWith('I.moveCursorTo'));
+
+        if (invalidCommands.length > 0) {
+          activeNote.commit(TestResult.FAILED);
+          return failedToolResult('hover', `Invalid commands: ${invalidCommands.join(', ')}. Hover tool only accepts I.moveCursorTo() commands.`, {
+            suggestion: 'Use click() to click elements, or form() for typing/selecting.',
+          });
+        }
+
+        const commands = rawCommands.map((cmd) => {
+          const trimmed = cmd.trim();
+          if (trimmed.startsWith('I.moveCursorTo')) return trimmed;
+          return `I.moveCursorTo(${JSON.stringify(trimmed)})`;
+        });
+
+        const previousState = ActionResult.fromState(stateManager.getCurrentState()!);
+        const action = explorer.createAction();
+        const attempts: Array<{ command: string; success: boolean; error?: string }> = [];
+
+        for (const command of commands) {
+          const success = await action.attempt(command, explanation, true);
+          attempts.push({
+            command,
+            success,
+            ...(action.lastError && { error: action.lastError.toString() }),
+          });
+
+          if (!success) continue;
+
+          const toolResult = await ActionResult.fromState(stateManager.getCurrentState()!).toToolResult(previousState, command);
+          activeNote.commit(TestResult.PASSED);
+          return successToolResult('hover', { ...toolResult, attempts, code: command }, action);
+        }
+
+        const toolResult = await ActionResult.fromState(stateManager.getCurrentState()!).toToolResult(previousState, commands[0]);
+        activeNote.commit(TestResult.FAILED);
+        return failedToolResult(
+          'hover',
+          'All hover commands failed',
+          {
+            ...toolResult,
+            attempts,
+            suggestion: 'Use xpathCheck() to locate the row/card/tree node, or visualClick() if the hover target is only visually identifiable.',
+          },
+          action.lastError
+        );
+      },
+    }),
+
     pressKey: tool({
       description: dedent`
         Press a keyboard key or key combination. Use this for special keys like Enter, Escape, Tab, Arrow keys, or key combinations with modifiers.
@@ -488,6 +566,7 @@ export function createAgentTools({
         Check the page contents based on current page state and screenshot.
         This tool will trigger visual research to check the page contents on request.
         Use it to verify the actions were performed correctly and the page is in the expected state.
+        Input schema has exactly one field: request. Do not pass text, reason, assertion, or other fields.
 
         <example>
         request: "Check current state of the Login form"

package/src/config.ts

@@ -59,6 +59,7 @@ interface AgentConfig extends HooksConfig {
   systemPrompt?: string;
   rules?: RuleEntry[];
   providerOptions?: Record<string, any>;
+  reasoning?: 'provider-default' | 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
 }
 
 interface ResearcherAgentConfig extends AgentConfig {

package/src/explorbot.ts

@@ -25,12 +25,13 @@ import { ExperienceTracker } from './experience-tracker.ts';
 import Explorer from './explorer.ts';
 import { KnowledgeTracker } from './knowledge-tracker.ts';
 import { WebPageState } from './state-manager.ts';
+import { Stats } from './stats.ts';
 import type { Suite } from './suite.ts';
 import { Plan, type Test } from './test-plan.ts';
-import { parsePlansFromMarkdown } from './utils/test-plan-markdown.ts';
 import { setVerboseMode, tag } from './utils/logger.ts';
 import { relativeToCwd } from './utils/next-steps.ts';
 import { sanitizeFilename } from './utils/strings.ts';
+import { parsePlansFromMarkdown } from './utils/test-plan-markdown.ts';
 
 export interface ExplorBotOptions {
   from?: string;
@@ -494,7 +495,10 @@ export class ExplorBot {
 
       const reporter = this.explorer?.getReporter();
       if (reporter?.isEnabled()) {
-        await reporter.setRunDescription(markdown);
+        let description = markdown;
+        const modelsTable = Stats.modelsTable(this.provider.getConfiguredModels());
+        if (modelsTable) description = `${markdown}\n\n${modelsTable}`;
+        await reporter.setRunDescription(description);
       }
 
       this.lastReportedTestCount = tests.length;

package/src/stats.ts

@@ -54,6 +54,24 @@ export class Stats {
     return String(num);
   }
 
+  static modelsTable(roleModels: Record<string, string>): string {
+    const usedModels = Object.entries(Stats.models).filter(([, tokens]) => tokens.total > 0);
+    if (usedModels.length === 0) return '';
+
+    const rolesByModel: Record<string, string[]> = {};
+    for (const [role, model] of Object.entries(roleModels)) {
+      if (!rolesByModel[model]) rolesByModel[model] = [];
+      rolesByModel[model].push(role);
+    }
+
+    const rows = usedModels.map(([model, tokens]) => {
+      const roles = rolesByModel[model]?.join(', ') || '-';
+      return `| ${roles} | ${model} | ${Stats.humanizeTokens(tokens.total)} |`;
+    });
+
+    return ['## Models', '', '| Role | Model | Tokens |', '| --- | --- | --- |', ...rows].join('\n');
+  }
+
   static hasActivity(): boolean {
     if (Stats.tests > 0 || Stats.plans > 0 || Stats.researches > 0) return true;
     const totalTokens = Object.values(Stats.models).reduce((sum, m) => sum + m.total, 0);