explorbot 0.1.32-beta.1 → 0.2.1

package/src/action.ts

@@ -1,30 +1,21 @@
 import fs from 'node:fs';
 import { join } from 'node:path';
-import { faker } from '@faker-js/faker';
 import { context, trace } from '@opentelemetry/api';
 import { container, recorder } from 'codeceptjs';
 import * as codeceptjs from 'codeceptjs';
-import { hopeThat, retryTo, tryTo, within } from 'codeceptjs/lib/effects';
-import step from 'codeceptjs/steps';
-import dedent from 'dedent';
 import { ActionResult } from './action-result.js';
 import { clearActivity, setActivity } from './activity.ts';
-import { ExperienceCompactor } from './ai/experience-compactor.js';
-import { Navigator } from './ai/navigator.js';
-import type { Provider } from './ai/provider.js';
 import { ConfigParser, outputPath } from './config.js';
 import type { ExplorbotConfig } from './config.js';
-import type { UserResolveFunction } from './explorbot.ts';
 import { Observability } from './observability.ts';
 import type { PlaywrightRecorder } from './playwright-recorder.ts';
 import type { StateManager } from './state-manager.js';
-import { isFatalBrowserError, isNavigationTransitionError } from './utils/browser-errors.ts';
-import { extractCodeBlocks } from './utils/code-extractor.js';
-import { htmlCombinedSnapshot, minifyHtml } from './utils/html.js';
+import { browserErrorMessage, isFatalBrowserError, isNavigationTransitionError } from './utils/browser-errors.ts';
+import { captureHtmlForSnapshot, htmlCombinedSnapshot, minifyHtml } from './utils/html.js';
 import { createDebug, setStepSpanParent, tag } from './utils/logger.js';
-import { waitForPageReadiness } from './utils/page-readiness.ts';
+import { sleep, waitForPageReadiness } from './utils/page-readiness.ts';
 import { safeFilename } from './utils/strings.ts';
-import { throttle } from './utils/throttle.ts';
+import { codeceptJSSandbox, hasPlaywrightCommands, playwrightSandbox, sanitizeCodeBlock } from './utils/web-sandbox.ts';
 
 const debugLog = createDebug('explorbot:action');
 const CAPTURE_NAVIGATION_TRANSITION_ATTEMPTS = 3;
@@ -37,24 +28,21 @@ class Action {
 
   // action info
   private action: string | null = null;
-  private expectation: string | null = null;
   public lastError: Error | null = null;
   public playwrightHelper: any;
   public playwrightGroupId: string | null = null;
   public assertionSteps: Array<{ name: string; args: any[] }> = [];
   private recorder?: PlaywrightRecorder;
+  private recovery: RecoveryRunner;
   private mainDocumentStatus: number | undefined = undefined;
 
-  constructor(actor: CodeceptJS.I, stateManager: StateManager, recorder?: PlaywrightRecorder) {
+  constructor(actor: CodeceptJS.I, stateManager: StateManager, recorder?: PlaywrightRecorder, recovery?: RecoveryRunner) {
     this.actor = actor;
     this.stateManager = stateManager;
     this.config = ConfigParser.getInstance().getConfig();
     this.playwrightHelper = container.helpers('Playwright');
     this.recorder = recorder;
-  }
-
-  async caputrePageWithScreenshot(): Promise<ActionResult> {
-    return this.capturePageState({ includeScreenshot: true });
+    this.recovery = recovery || ((fn) => fn());
   }
 
   async saveScreenshot(): Promise<string | undefined> {
@@ -73,7 +61,15 @@ class Action {
     }
   }
 
-  async capturePageState({ includeScreenshot = false }: { includeScreenshot?: boolean } = {}): Promise<ActionResult> {
+  async capturePageState(opts: { includeScreenshot?: boolean; codeBlock?: string } = {}): Promise<ActionResult> {
+    return this.recovery(() => this.captureOnce(opts));
+  }
+
+  async execute(code: string): Promise<Action> {
+    return this.recovery(() => this.executeOnce(code));
+  }
+
+  private async captureOnce({ includeScreenshot = false, codeBlock }: { includeScreenshot?: boolean; codeBlock?: string } = {}): Promise<ActionResult> {
     try {
       const currentState = this.stateManager.getCurrentState();
       const stateHash = currentState?.hash || 'screenshot';
@@ -166,10 +162,10 @@ class Action {
         ariaSnapshotFile,
         iframeURL: frame ? frame.url?.() || 'iframe' : undefined,
       });
-      this.stateManager.updateState(result);
+      this.stateManager.updateState(result, codeBlock);
       return result;
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
+      const msg = browserErrorMessage(err);
       if (isFatalBrowserError(err)) throw err;
       debugLog('capturePageState failed with non-fatal error:', msg);
       const url = this.playwrightHelper.page?.url?.() || '';
@@ -274,7 +270,7 @@ class Action {
     }
   }
 
-  async execute(code: string): Promise<Action> {
+  private async executeOnce(code: string): Promise<Action> {
     let error: Error | null = null;
 
     setActivity('🔎 Browsing...', 'action');
@@ -303,22 +299,19 @@ class Action {
 
       if (isPlaywright) {
         const page = this.playwrightHelper.page;
-        const asyncFn = createSandboxedFunction(['page'], `return (async () => { ${sanitizedCode} })()`);
-        await asyncFn(page);
+        await playwrightSandbox(page, sanitizedCode);
         await sleep(this.config.action?.delay || 500);
       } else {
-        const codeFunction = createSandboxedFunction(['I', 'tryTo', 'retryTo', 'within', 'hopeThat', 'step', 'faker'], sanitizedCode);
-        codeFunction(this.actor, tryTo, retryTo, within, hopeThat, step, faker);
+        codeceptJSSandbox(this.actor, sanitizedCode);
         await recorder.add(() => sleep(this.config.action?.delay || 500));
         await recorder.promise();
       }
 
-      const pageState = await this.capturePageState();
       if (executedSteps.length > 0) {
         codeString = executedSteps.join('\n');
       }
 
-      this.stateManager.updateState(pageState, codeString);
+      const pageState = await this.captureOnce({ codeBlock: codeString });
 
       this.actionResult = pageState;
       this.assertionSteps = assertionSteps;
@@ -345,66 +338,8 @@ class Action {
     return this;
   }
 
-  async expect(codeOrFunction: string | ((I: CodeceptJS.I) => void)): Promise<Action> {
-    const codeString = typeof codeOrFunction === 'string' ? codeOrFunction : codeOrFunction.toString();
-    this.expectation = codeString.toString();
-    const expectationPreview = sanitizeCodeBlock(codeString)
-      .split('\n')
-      .map((line) => line.trim())
-      .filter(Boolean)
-      .slice(0, 2)
-      .join(' ');
-    tag('step').log(`Expecting: ${expectationPreview || 'assertion'}`);
-    try {
-      debugLog('Executing expectation:', codeString);
-
-      let codeFunction: any;
-      if (typeof codeOrFunction === 'function') {
-        codeFunction = codeOrFunction;
-      } else {
-        const sanitizedCode = sanitizeCodeBlock(codeString);
-        if (!sanitizedCode) {
-          throw new Error('No valid I.* commands found in code block');
-        }
-        codeFunction = createSandboxedFunction(['I', 'tryTo', 'retryTo', 'within', 'hopeThat', 'step'], sanitizedCode);
-      }
-      codeFunction(this.actor, tryTo, retryTo, within, hopeThat, step);
-      await recorder.promise();
-      debugLog('Expectation executed successfully');
-
-      // Get current state from state manager
-      const currentState = this.stateManager.getCurrentState();
-      if (currentState) {
-        // Create ActionResult from current state for compatibility
-        this.actionResult = new ActionResult({
-          url: currentState.fullUrl || '',
-          title: currentState.title,
-          timestamp: currentState.timestamp,
-          html: '', // Empty HTML for expectation state
-        });
-      }
-
-      return this;
-    } catch (err) {
-      tag('error').log('Expectation failed:', errorToString(err));
-      this.lastError = err as Error;
-      await recorder.reset();
-      await recorder.start();
-      debugLog('Expectation failed:', errorToString(err));
-    } finally {
-      clearActivity();
-    }
-
-    return this;
-  }
-
-  public async waitForInteraction(): Promise<Action> {
-    // start with basic approach
-    await this.actor.wait(0.5);
-    return this;
-  }
-
-  public async attempt(codeBlock: string, originalMessage?: string, experience = true): Promise<boolean> {
+  public async attempt(codeBlock: string, originalMessage?: string): Promise<boolean> {
+    const wasInFrame = !!this.playwrightHelper.frame;
     try {
       debugLog('Resolution attempt...');
       setActivity('🦾 Acting in browser...', 'action');
@@ -412,38 +347,27 @@ class Action {
       if (!this.actionResult) {
         this.actionResult = ActionResult.fromState(this.stateManager.getCurrentState()!);
       }
-      const prevActionResult = this.actionResult;
       this.lastError = null;
       await this.execute(codeBlock);
 
-      if (!this.expectation && originalMessage) {
-        this.expectation = originalMessage;
-      }
-
-      if (!this.expectation) {
-        return true;
-      }
-
-      debugLog('Resolved Expectation:', this.expectation);
       return true;
     } catch (error) {
       this.lastError = error as Error;
       if (isFatalBrowserError(error)) throw error;
+      if (!wasInFrame) await this.exitIframe().catch(() => {});
       debugLog(`Attempt failed: ${codeBlock}: ${errorToString(error) || this.lastError?.toString()}`);
       return false;
     }
   }
 
-  getActor(): CodeceptJS.I {
-    return this.actor;
-  }
-
-  setActor(actor: CodeceptJS.I): void {
-    this.actor = actor;
+  async exitIframe(): Promise<void> {
+    if (!this.playwrightHelper.frame) return;
+    debugLog('Switching to main frame');
+    await this.playwrightHelper.switchTo();
   }
 
-  getCurrentState(): ActionResult | null {
-    return this.actionResult;
+  getActor(): CodeceptJS.I {
+    return this.actor;
   }
 
   getActionResult(): ActionResult | null {
@@ -460,6 +384,8 @@ class Action {
 
 export default Action;
 
+export type RecoveryRunner = <T>(fn: () => Promise<T>) => Promise<T>;
+
 function errorToString(error: any): string {
   if (error.cliMessage) {
     return error.cliMessage();
@@ -468,6 +394,11 @@ function errorToString(error: any): string {
 }
 
 async function captureHtml(page: any, frame: any, actor: any): Promise<string> {
+  for (const scope of [frame, page]) {
+    if (!scope?.evaluate) continue;
+    const html = await scope.evaluate(captureHtmlForSnapshot).catch(() => null);
+    if (typeof html === 'string') return html;
+  }
   if (frame?.content) return frame.content();
   if (page?.content) return page.content();
   if (actor?.grabSource) return actor.grabSource();
@@ -480,31 +411,6 @@ async function captureTitle(page: any, actor: any): Promise<string> {
   return '';
 }
 
-const SHADOWED_GLOBALS = ['process', 'global', 'globalThis', 'fetch', 'Bun', 'require', 'module', 'exports'];
-
-export function sanitizeCodeBlock(code: string): string {
-  return code
-    .split('\n')
-    .map((line) => line.trim())
-    .filter((line) => line.startsWith('I.') || line.startsWith('page.') || line.startsWith('await page.') || line.startsWith('await I.'))
-    .join('\n');
-}
-
-export function createSandboxedFunction(argNames: string[], body: string): (...args: any[]) => any {
-  const fn = new Function(...argNames, ...SHADOWED_GLOBALS, `'use strict';\n${body}`);
-  return (...args: any[]) => fn(...args);
-}
-
-function hasPlaywrightCommands(code: string): boolean {
-  return code.split('\n').some((line) => {
-    const trimmed = line.trim();
-    return trimmed.startsWith('page.') || trimmed.startsWith('await page.');
-  });
-}
-function sleep(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 const ASSERTION_STEP_NAMES = new Set(['see', 'dontSee', 'seeElement', 'dontSeeElement', 'seeInField', 'dontSeeInField', 'seeInCurrentUrl', 'dontSeeInCurrentUrl']);
 
 type StepListener = (step: any, error?: any) => void;

package/src/ai/agent.ts

@@ -1,3 +1,23 @@
+import type { RequestStore } from '../api/request-store.ts';
+import type { ExplorbotConfig } from '../config.ts';
+import type Explorer from '../explorer.ts';
+import type { KnowledgeTracker } from '../knowledge-tracker.ts';
+import type { PlaywrightRecorder } from '../playwright-recorder.ts';
+import type { StateManager } from '../state-manager.ts';
+import type { AIProvider } from './provider.ts';
+
 export interface Agent {
   emoji?: string;
 }
+
+export interface AgentDeps {
+  explorer: Explorer;
+  ai: AIProvider;
+  config: ExplorbotConfig;
+  stateManager: StateManager;
+  knowledgeTracker: KnowledgeTracker;
+  requestStore: RequestStore;
+  playwrightRecorder: PlaywrightRecorder;
+}
+
+export type ToolDeps = Pick<AgentDeps, 'explorer' | 'stateManager' | 'ai'>;

package/src/ai/captain/idle-mode.ts

@@ -66,7 +66,7 @@ export function WithIdleMode<T extends Constructor>(Base: T) {
               if (!action || action === 'replace') {
                 plan.tests.length = 0;
               }
-              const currentUrl = ctx.explorBot.getExplorer().getStateManager().getCurrentState()?.url || '';
+              const currentUrl = ctx.explorBot.stateManager().getCurrentState()?.url || '';
               for (const testInput of tests) {
                 const priority = testInput.priority || 'normal';
                 const expected = testInput.expected?.length ? testInput.expected : [];

package/src/ai/captain/test-mode.ts

@@ -146,7 +146,7 @@ export function WithTestMode<T extends Constructor>(Base: T) {
               if (!t) return { success: false, message: `Test "${session}" not found` };
               states = t.states;
             } else {
-              const stateManager = ctx.explorBot.getExplorer().getStateManager();
+              const stateManager = ctx.explorBot.stateManager();
               const history = stateManager.getStateHistory();
               const seen = new Set<string>();
               states = history

package/src/ai/captain/web-mode.ts

@@ -1,7 +1,6 @@
 import { tool } from 'ai';
 import dedent from 'dedent';
 import { z } from 'zod';
-import { ActionResult } from '../../action-result.ts';
 import { actionRule, locatorRule, sectionContextRule } from '../rules.ts';
 import { createAgentTools, createCodeceptJSTools } from '../tools.ts';
 import { type Constructor, type ModeContext, debugLog } from './mixin.ts';
@@ -10,17 +9,12 @@ export function WithWebMode<T extends Constructor>(Base: T) {
   return class extends Base {
     webModeTools(ctx: ModeContext): Record<string, any> {
       const explorer = ctx.explorBot.getExplorer();
-      const stateManager = explorer.getStateManager();
-      const codeceptTools = createCodeceptJSTools(explorer, ctx.task);
+      const toolDeps = { explorer, stateManager: ctx.explorBot.stateManager(), ai: ctx.explorBot.getProvider() };
+      const codeceptTools = createCodeceptJSTools(toolDeps, ctx.task);
       const agentTools = createAgentTools({
-        explorer,
+        ...toolDeps,
         researcher: ctx.explorBot.agentResearcher(),
         navigator: ctx.explorBot.agentNavigator(),
-        experienceTracker: stateManager.getExperienceTracker(),
-        getState: () => {
-          const state = stateManager.getCurrentState();
-          return state ? ActionResult.fromState(state) : null;
-        },
       });
       const { see, context, visualClick, learnExperience } = agentTools;
 
@@ -34,7 +28,7 @@ export function WithWebMode<T extends Constructor>(Base: T) {
             try {
               debugLog('navigate', destination);
               await ctx.explorBot.agentNavigator().visit(destination);
-              const stateManager = ctx.explorBot.getExplorer().getStateManager();
+              const stateManager = ctx.explorBot.stateManager();
               const state = stateManager.getCurrentState();
               return { success: true, url: state?.url, title: state?.title };
             } catch (error: any) {
@@ -52,48 +46,42 @@ export function WithWebMode<T extends Constructor>(Base: T) {
             - closeTabs: Close all browser tabs except the current one
             - reload: Reload the current page
             - screenshot: Take a screenshot of current page
-            - recover: Recover from a closed/crashed page using Explorer recovery
-            - restart: Restart the browser when page/context recovery is not enough
-            - openFreshTab: Open a fresh tab in the current browser context
+            - recover: Recover from a closed/crashed page, escalating to a full browser restart when needed
+            - openTab: Open a fresh tab in the current browser context
           `,
           inputSchema: z.object({
-            action: z.enum(['status', 'evaluate', 'closeTabs', 'reload', 'screenshot', 'recover', 'restart', 'openFreshTab']).describe('Browser action to perform'),
+            action: z.enum(['status', 'evaluate', 'closeTabs', 'reload', 'screenshot', 'recover', 'openTab']).describe('Browser action to perform'),
             code: z.string().optional().describe('JavaScript code for evaluate action'),
           }),
           execute: async ({ action, code }) => {
             const explorer = ctx.explorBot.getExplorer();
 
             if (action === 'status') {
-              const page = explorer.playwrightHelper?.page;
+              const page = explorer.page;
               const pages = page?.context?.().pages?.() || [];
               return {
                 success: true,
                 hasPage: !!page,
-                isClosed: page?.isClosed?.() || false,
-                url: page && !page.isClosed?.() ? await page.url() : null,
-                title: page && !page.isClosed?.() ? await page.title().catch(() => null) : null,
+                isClosed: !page,
+                url: page ? await page.url() : null,
+                title: page ? await page.title().catch(() => null) : null,
                 tabs: pages.length,
               };
             }
 
             if (action === 'recover') {
-              const recovered = await explorer.recoverFromBrowserError();
-              return { success: recovered, message: recovered ? 'Browser page recovered' : 'Browser recovery failed' };
+              const { ok } = await explorer.recover();
+              return { success: ok, message: ok ? 'Browser page recovered' : 'Browser recovery failed' };
             }
 
-            if (action === 'restart') {
-              const restarted = await explorer.restartBrowser();
-              return { success: restarted, message: restarted ? 'Browser restarted' : 'Browser restart failed' };
-            }
-
-            if (action === 'openFreshTab') {
-              await ctx.explorBot.openFreshTab();
-              const state = explorer.getStateManager().getCurrentState();
+            if (action === 'openTab') {
+              await ctx.explorBot.openTab();
+              const state = ctx.explorBot.stateManager().getCurrentState();
               return { success: true, url: state?.url, title: state?.title };
             }
 
-            const page = explorer.playwrightHelper?.page;
-            if (!page || page.isClosed?.()) return { success: false, message: 'No browser page available. Try browser({ action: "recover" }) first.' };
+            const page = explorer.page;
+            if (!page) return { success: false, message: 'No browser page available. Try browser({ action: "recover" }) first.' };
 
             if (action === 'evaluate') {
               if (!code) return { success: false, message: 'Code required for evaluate action' };

package/src/ai/captain.ts

@@ -2,10 +2,11 @@ import { tool } from 'ai';
 import dedent from 'dedent';
 import { z } from 'zod';
 import { ActionResult } from '../action-result.js';
-import { ExperienceTracker } from '../experience-tracker.js';
+import type { ExperienceTracker } from '../experience-tracker.js';
 import type { ExplorBot } from '../explorbot.ts';
 import type { WebPageState } from '../state-manager.ts';
 import { Task, Test } from '../test-plan.ts';
+import { formatHeadings } from '../utils/context-formatter.ts';
 import { HooksRunner } from '../utils/hooks-runner.ts';
 import { startLogCapture, stopLogCapture, tag } from '../utils/logger.js';
 import { loop } from '../utils/loop.js';
@@ -37,7 +38,7 @@ export class Captain extends CaptainBase implements Agent {
   constructor(explorBot: ExplorBot) {
     super();
     this.explorBot = explorBot;
-    this.experienceTracker = new ExperienceTracker();
+    this.experienceTracker = explorBot.experienceTracker();
   }
 
   setCommandExecutor(fn: (cmd: string) => Promise<void>, descriptions: { name: string; description: string; options: string }[]): void {
@@ -48,7 +49,7 @@ export class Captain extends CaptainBase implements Agent {
   private getHooksRunner(): HooksRunner {
     if (!this.hooksRunner) {
       const explorer = this.explorBot.getExplorer();
-      this.hooksRunner = new HooksRunner(explorer, explorer.getConfig());
+      this.hooksRunner = new HooksRunner(explorer, this.explorBot.getConfig());
     }
     return this.hooksRunner;
   }
@@ -62,7 +63,7 @@ export class Captain extends CaptainBase implements Agent {
   }
 
   protected getKnowledgeTracker() {
-    return this.explorBot.getExplorer().getKnowledgeTracker();
+    return this.explorBot.knowledgeTracker();
   }
 
   protected getProvider(): Provider {
@@ -88,17 +89,16 @@ export class Captain extends CaptainBase implements Agent {
   getMode(): CaptainMode {
     const explorer = this.explorBot.getExplorer();
     const activeTest = explorer.activeTest;
-    const page = explorer.playwrightHelper?.page;
 
-    if (activeTest && (!page || page.isClosed?.())) return 'heal';
+    if (activeTest && !explorer.page) return 'heal';
     if (activeTest) return 'test';
-    if (explorer.getStateManager().getCurrentState()) return 'web';
+    if (this.explorBot.stateManager().getCurrentState()) return 'web';
     return 'idle';
   }
 
   private systemPrompt(): string {
     const mode = this.getMode();
-    const currentUrl = this.explorBot.getExplorer().getStateManager().getCurrentState()?.url;
+    const currentUrl = this.explorBot.stateManager().getCurrentState()?.url;
     const customPrompt = this.explorBot.getProvider().getSystemPromptForAgent('captain', currentUrl);
 
     return dedent`
@@ -145,17 +145,8 @@ export class Captain extends CaptainBase implements Agent {
     return this.conversation;
   }
 
-  getConversation(): Conversation | null {
-    return this.conversation;
-  }
-
-  cleanConversation(): void {
-    this.conversation = null;
-    tag('info').log('Conversation cleaned');
-  }
-
   private async getPageContext(): Promise<string> {
-    const state = this.explorBot.getExplorer().getStateManager().getCurrentState();
+    const state = this.explorBot.stateManager().getCurrentState();
     if (!state) {
       return 'No page loaded';
     }
@@ -164,11 +155,7 @@ export class Captain extends CaptainBase implements Agent {
     const knowledge = this.getKnowledge(actionResult);
     const experience = this.getExperience(actionResult);
 
-    const headingLines: string[] = [];
-    if (state.h1) headingLines.push(`H1: ${state.h1}`);
-    if (state.h2) headingLines.push(`H2: ${state.h2}`);
-    if (state.h3) headingLines.push(`H3: ${state.h3}`);
-    if (state.h4) headingLines.push(`H4: ${state.h4}`);
+    const headingLines = formatHeadings(state);
     const headingsBlock = headingLines.join('\n');
 
     let pageSummary = '';
@@ -233,10 +220,9 @@ export class Captain extends CaptainBase implements Agent {
   }
 
   private async reinjectContextIfNeeded(conversation: Conversation, currentState: WebPageState): Promise<void> {
-    if (conversation.hasTag('page_html', 5)) return Promise.resolve();
+    if (conversation.hasTag('page_aria', 5)) return;
 
     const actionResult = ActionResult.fromState(currentState);
-    const html = await actionResult.combinedHtml();
     const context = dedent`
         Context:
 
@@ -248,13 +234,8 @@ export class Captain extends CaptainBase implements Agent {
         <page_aria>
         ${actionResult.getInteractiveARIA()}
         </page_aria>
-
-        <page_html>
-        ${html}
-        </page_html>
       `;
     conversation.addUserText(context);
-    return Promise.resolve();
   }
 
   private coreTools(task: Task, onDone: (summary: string) => void) {
@@ -285,15 +266,8 @@ export class Captain extends CaptainBase implements Agent {
       runCommand: tool({
         description: dedent`
           Execute a TUI command. Returns log output from command execution.
-          Use only when the user explicitly asks to run a slash command.
-          Never use this to analyze files, reports, logs, plans, generated tests, knowledge, or experience.
-          Never run a slash command unless the user request itself starts with that slash command.
-          ${this.commandDescriptions
-            .map((c) => {
-              const opts = c.options ? ` (${c.options})` : '';
-              return `${c.name} — ${c.description}${opts}`;
-            })
-            .join('\n')}
+          Use only when the user request itself starts with a slash command; pass it through verbatim.
+          Available commands: ${this.commandDescriptions.map((c) => c.name).join(', ')}
         `,
         inputSchema: z.object({
           command: z.string().describe('Slash command to execute, e.g. "/research", "/plan authentication", "/test brave-fox123"'),
@@ -351,7 +325,7 @@ export class Captain extends CaptainBase implements Agent {
     }
 
     const pilotAnalysis = this.explorBot.agentPilot().getLastAnalysis() || '';
-    const currentUrl = this.explorBot.getExplorer().getStateManager().getCurrentState()?.url || '';
+    const currentUrl = this.explorBot.stateManager().getCurrentState()?.url || '';
 
     const schema = z.object({
       action: z.enum(['inject', 'stop', 'pass', 'skip']),
@@ -402,7 +376,7 @@ export class Captain extends CaptainBase implements Agent {
 
   async processExecutionError(error: Error, activeTest: Test): Promise<ExecutionRecoveryAction> {
     const explorer = this.explorBot.getExplorer();
-    const result = await explorer.handleExecutionError(error);
+    const result = await explorer.recover(error);
     return {
       ...result,
       message: result.recovered ? `${result.message}\nContinue the test "${activeTest.scenario}" from the restored page.` : result.message,
@@ -414,7 +388,7 @@ export class Captain extends CaptainBase implements Agent {
   }
 
   async handle(input: string, options: { reset?: boolean } = {}): Promise<string | null> {
-    const stateManager = this.explorBot.getExplorer().getStateManager();
+    const stateManager = this.explorBot.stateManager();
     const initialState = stateManager.getCurrentState();
 
     const conversation = options.reset ? this.resetConversation() : this.ensureConversation();
@@ -489,6 +463,7 @@ export class Captain extends CaptainBase implements Agent {
         const result = await this.explorBot.getProvider().invokeConversation(conversation, tools, {
           maxToolRoundtrips: 5,
           toolChoice: 'auto',
+          stopWhen: () => isDone,
         });
 
         if (!result) {