explorbot 0.1.30 → 0.1.32-beta.1

package/dist/boat/api-tester/example/apibot.config.js

@@ -0,0 +1,30 @@
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+const openrouter = createOpenRouter({
+    apiKey: process.env.OPENROUTER_API_KEY,
+});
+export default {
+    ai: {
+        model: openrouter('mistralai/devstral-small:nitro') //   openrouter('x-ai/grok-4-fast') // openrouter('moonshotai/kimi-k2.5:nitro'), // openrouter('x-ai/grok-4-fast') // minimax/minimax-m2.5:nitro
+    },
+    api: {
+        baseEndpoint: 'http://localhost:3000/api/v2/amr_testing',
+        headers: {
+            'Authorization': `Bearer ${process.env.TESTOMATIO_API_KEY}`,
+            'Content-Type': 'application/json',
+        },
+        spec: [
+            'http://127.0.0.1:3000/api/v2/openapi'
+        ],
+        // bootstrap: async ({ headers, baseEndpoint }) => {
+        //   // Run before tests — e.g. obtain auth token
+        //   // Return headers to merge: { Authorization: 'Bearer ...' }
+        // },
+        // teardown: async ({ headers, baseEndpoint }) => {
+        //   // Run after tests — e.g. cleanup test data
+        // },
+    },
+    dirs: {
+        output: 'output',
+        knowledge: 'knowledge',
+    },
+};

package/dist/package.json

@@ -1,39 +1,30 @@
 {
   "name": "explorbot",
-  "version": "0.1.30",
+  "version": "0.1.32-beta.1",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",
   "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
   "exports": {
     ".": {
-      "bun": "./src/index.tsx",
+      "types": "./dist/src/index.d.ts",
+      "bun": "./src/index.ts",
       "import": "./dist/src/index.js"
     }
   },
   "bin": {
     "explorbot": "./dist/bin/explorbot-cli.js"
   },
-  "files": [
-    "dist/",
-    "src/**/*.ts",
-    "src/**/*.tsx",
-    "bin/**/*.ts",
-    "boat/api-tester/src/**/*.ts",
-    "boat/doc-collector/src/**/*.ts",
-    "boat/doc-collector/bin/**/*.ts",
-    "boat/doc-collector/package.json",
-    "rules/",
-    "assets/sample-files/"
-  ],
+  "files": ["dist/", "src/**/*.ts", "src/**/*.tsx", "bin/**/*.ts", "boat/api-tester/src/**/*.ts", "boat/doc-collector/src/**/*.ts", "boat/doc-collector/bin/**/*.ts", "boat/doc-collector/package.json", "rules/", "assets/sample-files/"],
   "scripts": {
-    "build": "bun run src/index.tsx build && bun run build:bin",
+    "build": "bun run build:bin",
     "build:bin": "bun build bin/explorbot-cli.ts --outdir bin --target node --external commander --format esm",
     "build:npm": "bash scripts/build-npm.sh",
     "prepublishOnly": "npm run build:npm",
-    "dev": "bun run src/index.tsx",
-    "start": "node dist/index.js",
-    "init": "bun run src/index.tsx init",
+    "dev": "bun run bin/explorbot-cli.ts start",
+    "start": "node dist/bin/explorbot-cli.js",
+    "init": "bun run bin/explorbot-cli.ts init",
     "test": "codeceptjs run",
     "test:headless": "codeceptjs run --headless",
     "test:ui": "bun test tests/ui",
@@ -52,13 +43,7 @@
     "check:fix": "biome check --write .",
     "langfuse:export": "bun run .claude/skills/explorbot-debug/langfuse-export.ts"
   },
-  "keywords": [
-    "cli",
-    "react",
-    "ink",
-    "codeceptjs",
-    "playwright"
-  ],
+  "keywords": ["cli", "react", "ink", "codeceptjs", "playwright"],
   "repository": {
     "type": "git",
     "url": "https://github.com/testomatio/explorbot"
@@ -74,7 +59,7 @@
     "@faker-js/faker": "^10.4.0",
     "@inkjs/ui": "^2.0.0",
     "@langfuse/otel": "^4.5.1",
-    "@openrouter/ai-sdk-provider": "^2.3.3",
+    "@openrouter/ai-sdk-provider": "^3.0.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/auto-instrumentations-node": "^0.67.3",
     "@opentelemetry/instrumentation": "^0.208.0",

package/dist/src/action-result.d.ts

@@ -0,0 +1,133 @@
+import { type HtmlConfig } from './config.js';
+import type { Link, WebPageState } from './state-manager.js';
+import { type HtmlDiffPart, type HtmlDiffResult } from './utils/html-diff.js';
+interface ActionResultData extends WebPageState {
+    html?: string;
+    fullUrl?: string | undefined;
+    screenshot?: Buffer;
+    screenshotFile?: string;
+    logFile?: string;
+    htmlFile?: string;
+    title?: string;
+    timestamp?: Date;
+    error?: string | null;
+    h1?: string | undefined;
+    h2?: string | undefined;
+    h3?: string | undefined;
+    h4?: string | undefined;
+    browserLogs?: any[];
+    iframeSnapshots?: Array<{
+        src: string;
+        html: string;
+        id?: string;
+    }>;
+    ariaSnapshot?: string | null;
+    ariaSnapshotFile?: string;
+    iframeURL?: string;
+    links?: Link[];
+}
+export interface PageDiff {
+    urlChanged: boolean;
+    previousUrl?: string;
+    currentUrl: string;
+    ariaChanges?: string | null;
+    htmlParts?: HtmlDiffPart[];
+    iframes?: string;
+}
+export interface ToolResultMetadata {
+    url: string;
+    locator: string;
+    targetedHtml: string;
+    pageDiff: PageDiff | null;
+    iframeURL?: string;
+}
+export declare class ActionResult implements ActionResultData {
+    id?: number;
+    title: string;
+    httpStatus: number | undefined;
+    error: string | null;
+    timestamp: Date;
+    h1: string | undefined;
+    h2: string | undefined;
+    h3: string | undefined;
+    h4: string | undefined;
+    url: string;
+    fullUrl: string | undefined;
+    browserLogs: any[];
+    iframeSnapshots: Array<{
+        src: string;
+        html: string;
+        id?: string;
+    }>;
+    iframeURL: string | undefined;
+    readonly screenshotFile: string | undefined;
+    _screenshot: Buffer | undefined;
+    readonly htmlFile: string | undefined;
+    _html: string | undefined;
+    snapshotCache: Map<string, string>;
+    readonly logFile: string | undefined;
+    _browserLogs: any[] | undefined;
+    readonly ariaSnapshotFile: string | undefined;
+    _ariaSnapshot: string | null | undefined;
+    _lastExtractedHtml: string | undefined;
+    notes: any;
+    links: Link[];
+    verifications?: Record<string, boolean>;
+    constructor(data: ActionResultData);
+    get hash(): string;
+    get html(): string;
+    set html(value: string);
+    get screenshot(): Buffer | undefined;
+    get browserLogsContent(): any[];
+    get ariaSnapshot(): string | null;
+    set ariaSnapshot(value: string | null);
+    extractHeadings(html: string): void;
+    addVerification(assertion: string, passed: boolean): void;
+    getVerification(message: string | RegExp): boolean | null;
+    isSameUrl(state: WebPageState): boolean;
+    isMatchedBy(state: WebPageState): boolean;
+    isRelevantExperienceRecord(record: WebPageState, options?: {
+        includeDescendantExperience?: boolean;
+    }): boolean;
+    simplifiedHtml(htmlConfig?: HtmlConfig): Promise<string>;
+    combinedHtml(htmlConfig?: HtmlConfig & {
+        keepPositions?: boolean;
+    }): Promise<string>;
+    textHtml(htmlConfig?: HtmlConfig): Promise<string>;
+    getInteractiveARIA(): string;
+    getCompactARIA(): string;
+    normalizeHtmlConfig(htmlConfig?: HtmlConfig): HtmlConfig | undefined;
+    cachedSnapshot(key: string, compute: () => Promise<string>): Promise<string>;
+    static fromState(state: WebPageState): ActionResult;
+    static loadHtmlFromFile(htmlFile: string): string | null;
+    static loadScreenshotFromFile(screenshotFile: string): Buffer | undefined;
+    static loadBrowserLogsFromFile(logFile: string): any[];
+    static loadAriaSnapshotFromFile(ariaSnapshotFile: string): string | null;
+    toAiContext(): string;
+    get relativeUrl(): string | null;
+    get isInsideIframe(): boolean;
+    getStateHash(): string;
+    saveBrowserLogs(): void;
+    saveHtmlOutput(): void;
+    diff(previousState: ActionResult | null): Promise<Diff>;
+    toToolResult(previousState: ActionResult | null, locator: string): Promise<ToolResultMetadata>;
+}
+export declare class Diff {
+    current: ActionResult;
+    previous: ActionResult | null;
+    _htmlDiffResult: HtmlDiffResult | null;
+    _ariaDiffResult: string | null;
+    _isSameUrl: boolean;
+    _urlChanged: boolean;
+    constructor(current: ActionResult, previous: ActionResult | null);
+    hasChanges(): boolean;
+    isSameUrl(): boolean;
+    urlHasChanged(): boolean;
+    get htmlParts(): HtmlDiffPart[];
+    get ariaChanged(): string | null;
+    get ariaRemoved(): string | null;
+    get htmlDiff(): HtmlDiffResult | null;
+    get ariaDiff(): string | null;
+    calculate(): Promise<void>;
+}
+export {};

package/dist/src/action-result.js

@@ -26,6 +26,7 @@ export class ActionResult {
     _screenshot = undefined;
     htmlFile = undefined;
     _html = undefined;
+    snapshotCache = new Map();
     logFile = undefined;
     _browserLogs = undefined;
     ariaSnapshotFile = undefined;
@@ -100,6 +101,7 @@ export class ActionResult {
     }
     set html(value) {
         this._html = value;
+        this.snapshotCache.clear();
     }
     get screenshot() {
         if (this._screenshot) {
@@ -206,19 +208,24 @@ export class ActionResult {
     }
     async simplifiedHtml(htmlConfig) {
         const normalizedConfig = this.normalizeHtmlConfig(htmlConfig);
-        return await minifyHtml(htmlMinimalUISnapshot(this.html ?? '', normalizedConfig?.minimal));
+        const cacheKey = `simplified:${JSON.stringify(normalizedConfig?.minimal ?? null)}`;
+        return this.cachedSnapshot(cacheKey, () => minifyHtml(htmlMinimalUISnapshot(this.html ?? '', normalizedConfig?.minimal)));
     }
     async combinedHtml(htmlConfig) {
         const normalizedConfig = this.normalizeHtmlConfig(htmlConfig);
-        const combinedHtml = await minifyHtml(htmlCombinedSnapshot(this.html ?? '', normalizedConfig?.combined, { keepPositions: htmlConfig?.keepPositions }));
-        debugLog(`----${this.url}----`);
-        debugLog(`Combined HTML: \n${combinedHtml}`);
-        debugLog('----');
-        return combinedHtml;
+        const cacheKey = `combined:${!!htmlConfig?.keepPositions}:${JSON.stringify(normalizedConfig?.combined ?? null)}`;
+        return this.cachedSnapshot(cacheKey, async () => {
+            const combinedHtml = await minifyHtml(htmlCombinedSnapshot(this.html ?? '', normalizedConfig?.combined, { keepPositions: htmlConfig?.keepPositions }));
+            debugLog(`----${this.url}----`);
+            debugLog(`Combined HTML: \n${combinedHtml}`);
+            debugLog('----');
+            return combinedHtml;
+        });
     }
     async textHtml(htmlConfig) {
         const normalizedConfig = this.normalizeHtmlConfig(htmlConfig);
-        return await minifyHtml(htmlTextSnapshot(this.html ?? '', normalizedConfig?.text));
+        const cacheKey = `text:${JSON.stringify(normalizedConfig?.text ?? null)}`;
+        return this.cachedSnapshot(cacheKey, () => minifyHtml(htmlTextSnapshot(this.html ?? '', normalizedConfig?.text)));
     }
     getInteractiveARIA() {
         return compactAriaSnapshot(this.ariaSnapshot, false);
@@ -233,6 +240,14 @@ export class ActionResult {
         const parser = ConfigParser.getInstance();
         return parser.getConfig().html;
     }
+    async cachedSnapshot(key, compute) {
+        const cached = this.snapshotCache.get(key);
+        if (cached !== undefined)
+            return cached;
+        const value = await compute();
+        this.snapshotCache.set(key, value);
+        return value;
+    }
     static fromState(state) {
         let html = undefined;
         let screenshot = undefined;

package/dist/src/action.d.ts

@@ -0,0 +1,50 @@
+import { ActionResult } from './action-result.js';
+import type { ExplorbotConfig } from './config.js';
+import type { PlaywrightRecorder } from './playwright-recorder.js';
+import type { StateManager } from './state-manager.js';
+declare class Action {
+    actor: CodeceptJS.I;
+    stateManager: StateManager;
+    actionResult: ActionResult | null;
+    config: ExplorbotConfig;
+    action: string | null;
+    expectation: string | null;
+    lastError: Error | null;
+    playwrightHelper: any;
+    playwrightGroupId: string | null;
+    assertionSteps: Array<{
+        name: string;
+        args: any[];
+    }>;
+    recorder?: PlaywrightRecorder;
+    mainDocumentStatus: number | undefined;
+    constructor(actor: CodeceptJS.I, stateManager: StateManager, recorder?: PlaywrightRecorder);
+    caputrePageWithScreenshot(): Promise<ActionResult>;
+    saveScreenshot(): Promise<string | undefined>;
+    capturePageState({ includeScreenshot }?: {
+        includeScreenshot?: boolean;
+    }): Promise<ActionResult>;
+    captureMainDocumentStatus(): Promise<number | undefined>;
+    captureMainDocumentResponse(): () => void;
+    /**
+     * Capture HTML snapshots of all iframes on the page
+     */
+    captureIframeSnapshots(mainHtml: string): Promise<Array<{
+        src: string;
+        html: string;
+        id?: string;
+    }>>;
+    captureBrowserLogs(): Promise<any[]>;
+    execute(code: string): Promise<Action>;
+    expect(codeOrFunction: string | ((I: CodeceptJS.I) => void)): Promise<Action>;
+    waitForInteraction(): Promise<Action>;
+    attempt(codeBlock: string, originalMessage?: string, experience?: boolean): Promise<boolean>;
+    getActor(): CodeceptJS.I;
+    setActor(actor: CodeceptJS.I): void;
+    getCurrentState(): ActionResult | null;
+    getActionResult(): ActionResult | null;
+    waitForPageReadiness(page: any): Promise<void>;
+}
+export default Action;
+export declare function sanitizeCodeBlock(code: string): string;
+export declare function createSandboxedFunction(argNames: string[], body: string): (...args: any[]) => any;

package/dist/src/action.js

@@ -272,12 +272,12 @@ class Action {
             }
             if (isPlaywright) {
                 const page = this.playwrightHelper.page;
-                const asyncFn = new Function('page', `return (async () => { ${sanitizedCode} })()`);
+                const asyncFn = createSandboxedFunction(['page'], `return (async () => { ${sanitizedCode} })()`);
                 await asyncFn(page);
                 await sleep(this.config.action?.delay || 500);
             }
             else {
-                const codeFunction = new Function('I', 'tryTo', 'retryTo', 'within', 'hopeThat', 'step', 'faker', sanitizedCode);
+                const codeFunction = createSandboxedFunction(['I', 'tryTo', 'retryTo', 'within', 'hopeThat', 'step', 'faker'], sanitizedCode);
                 codeFunction(this.actor, tryTo, retryTo, within, hopeThat, step, faker);
                 await recorder.add(() => sleep(this.config.action?.delay || 500));
                 await recorder.promise();
@@ -334,7 +334,7 @@ class Action {
                 if (!sanitizedCode) {
                     throw new Error('No valid I.* commands found in code block');
                 }
-                codeFunction = new Function('I', 'tryTo', 'retryTo', 'within', 'hopeThat', 'step', sanitizedCode);
+                codeFunction = createSandboxedFunction(['I', 'tryTo', 'retryTo', 'within', 'hopeThat', 'step'], sanitizedCode);
             }
             codeFunction(this.actor, tryTo, retryTo, within, hopeThat, step);
             await recorder.promise();
@@ -438,13 +438,18 @@ async function captureTitle(page, actor) {
         return actor.grabTitle();
     return '';
 }
-function sanitizeCodeBlock(code) {
+const SHADOWED_GLOBALS = ['process', 'global', 'globalThis', 'fetch', 'Bun', 'require', 'module', 'exports'];
+export function sanitizeCodeBlock(code) {
     return code
         .split('\n')
         .map((line) => line.trim())
-        .filter((line) => line.startsWith('I.') || line.startsWith('page.') || line.startsWith('await '))
+        .filter((line) => line.startsWith('I.') || line.startsWith('page.') || line.startsWith('await page.') || line.startsWith('await I.'))
         .join('\n');
 }
+export function createSandboxedFunction(argNames, body) {
+    const fn = new Function(...argNames, ...SHADOWED_GLOBALS, `'use strict';\n${body}`);
+    return (...args) => fn(...args);
+}
 function hasPlaywrightCommands(code) {
     return code.split('\n').some((line) => {
         const trimmed = line.trim();

package/dist/src/activity.d.ts

@@ -0,0 +1,26 @@
+export interface ActivityEntry {
+    message: string;
+    timestamp: Date;
+    type?: 'ai' | 'action' | 'navigation' | 'general';
+}
+type ActivityListener = (activity: ActivityEntry | null) => void;
+declare class Activity {
+    static instance: Activity;
+    currentActivity: ActivityEntry | null;
+    listeners: ActivityListener[];
+    clearTimeoutId: NodeJS.Timeout | null;
+    constructor();
+    static getInstance(): Activity;
+    setActivity(message: string, type?: ActivityEntry['type']): void;
+    clearActivity(force?: boolean): void;
+    getCurrentActivity(): ActivityEntry | null;
+    addListener(listener: ActivityListener): void;
+    removeListener(listener: ActivityListener): void;
+    notifyListeners(): void;
+}
+export declare const setActivity: (message: string, type?: ActivityEntry["type"]) => void;
+export declare const clearActivity: (force?: boolean) => void;
+export declare const getCurrentActivity: () => ActivityEntry;
+export declare const addActivityListener: (listener: ActivityListener) => void;
+export declare const removeActivityListener: (listener: ActivityListener) => void;
+export default Activity;

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

@@ -0,0 +1,3 @@
+export interface Agent {
+    emoji?: string;
+}

package/dist/src/ai/captain/file-tools.d.ts

@@ -0,0 +1,28 @@
+export declare const CAPTAIN_ARTIFACT_DIRS: readonly ["reports", "plans", "tests", "states"];
+export declare const CAPTAIN_ALLOWED_READ_DIRS: readonly ["output", "knowledge", "experience"];
+export declare const CAPTAIN_ARTIFACT_SCAN_LIMIT = 200;
+export declare const CAPTAIN_ARTIFACT_LIST_LIMIT = 20;
+export declare const CAPTAIN_READ_FILE_DEFAULT_LIMIT = 12000;
+export declare const CAPTAIN_READ_FILE_MAX_LIMIT = 50000;
+export declare const CAPTAIN_READ_FILE_MIN_LIMIT = 1000;
+export declare function listRecentArtifacts(outputDir: string): Array<{
+    path: string;
+    size: number;
+    modifiedAt: string;
+}>;
+export declare function readCaptainFile(projectRoot: string | null, input: ReadCaptainFileInput, allowedDirs?: readonly string[]): ReadCaptainFileResult;
+export interface ReadCaptainFileInput {
+    path: string;
+    startLine?: number;
+    endLine?: number;
+    maxChars?: number;
+}
+export type ReadCaptainFileResult = {
+    success: true;
+    path: string;
+    truncated: boolean;
+    content: string;
+} | {
+    success: false;
+    message: string;
+};

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

@@ -0,0 +1,11 @@
+import { type Constructor, type ModeContext } from './mixin.js';
+export declare function WithIdleMode<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        idleModeTools(ctx: ModeContext): Promise<Record<string, any>>;
+        idleModePrompt(): string;
+    };
+} & T;
+export interface IdleModeMethods {
+    idleModeTools(ctx: ModeContext): Promise<Record<string, any>>;
+    idleModePrompt(): string;
+}

package/dist/src/ai/captain/mixin.d.ts

@@ -0,0 +1,10 @@
+import type { ExplorBot } from '../../explorbot.js';
+import type { Task } from '../../test-plan.js';
+export type Constructor<T = object> = new (...args: any[]) => T;
+export declare const debugLog: (...args: any[]) => void;
+export type CaptainMode = 'idle' | 'web' | 'test' | 'heal';
+export interface ModeContext {
+    explorBot: ExplorBot;
+    task: Task;
+}
+export declare function resolveProjectRoot(): string | null;

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

@@ -0,0 +1,13 @@
+import { type Constructor, type ModeContext } from './mixin.js';
+export declare function WithTestMode<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        testModeTools(ctx: ModeContext): Record<string, any>;
+        testModePrompt(): string;
+        testModeRules(): string;
+    };
+} & T;
+export interface TestModeMethods {
+    testModeTools(ctx: ModeContext): Record<string, any>;
+    testModePrompt(): string;
+    testModeRules(): string;
+}

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

@@ -0,0 +1,13 @@
+import { type Constructor, type ModeContext } from './mixin.js';
+export declare function WithWebMode<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        webModeTools(ctx: ModeContext): Record<string, any>;
+        webModePrompt(): string;
+        webModeRules(): string;
+    };
+} & T;
+export interface WebModeMethods {
+    webModeTools(ctx: ModeContext): Record<string, any>;
+    webModePrompt(): string;
+    webModeRules(): string;
+}

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

@@ -0,0 +1,143 @@
+import { ExperienceTracker } from '../experience-tracker.js';
+import type { ExplorBot } from '../explorbot.js';
+import type { WebPageState } from '../state-manager.js';
+import { Task, Test } from '../test-plan.js';
+import { HooksRunner } from '../utils/hooks-runner.js';
+import type { Agent } from './agent.js';
+import { type CaptainMode, type ModeContext } from './captain/mixin.js';
+import { type Conversation } from './conversation.js';
+import type { Navigator } from './navigator.js';
+import type { Provider } from './provider.js';
+import { TaskAgent } from './task-agent.js';
+declare const CaptainBase: {
+    new (...args: any[]): {
+        testModeTools(ctx: ModeContext): Record<string, any>;
+        testModePrompt(): string;
+        testModeRules(): string;
+    };
+} & {
+    new (...args: any[]): {
+        webModeTools(ctx: ModeContext): Record<string, any>;
+        webModePrompt(): string;
+        webModeRules(): string;
+    };
+} & {
+    new (...args: any[]): {
+        idleModeTools(ctx: ModeContext): Promise<Record<string, any>>;
+        idleModePrompt(): string;
+    };
+} & (new (...args: any[]) => TaskAgent);
+export declare class Captain extends CaptainBase implements Agent {
+    emoji: string;
+    explorBot: ExplorBot;
+    conversation: Conversation | null;
+    experienceTracker: ExperienceTracker;
+    hooksRunner: HooksRunner | null;
+    commandExecutor: ((cmd: string) => Promise<void>) | null;
+    commandDescriptions: {
+        name: string;
+        description: string;
+        options: string;
+    }[];
+    constructor(explorBot: ExplorBot);
+    setCommandExecutor(fn: (cmd: string) => Promise<void>, descriptions: {
+        name: string;
+        description: string;
+        options: string;
+    }[]): void;
+    getHooksRunner(): HooksRunner;
+    getNavigator(): Navigator;
+    getExperienceTracker(): ExperienceTracker;
+    getKnowledgeTracker(): import("../knowledge-tracker.js").KnowledgeTracker;
+    getProvider(): Provider;
+    trackToolExecutions(toolExecutions: any[]): void;
+    getMode(): CaptainMode;
+    systemPrompt(): string;
+    resetConversation(): Conversation;
+    ensureConversation(): Conversation;
+    getConversation(): Conversation | null;
+    cleanConversation(): void;
+    getPageContext(): Promise<string>;
+    planSummary(): string;
+    reinjectContextIfNeeded(conversation: Conversation, currentState: WebPageState): Promise<void>;
+    coreTools(task: Task, onDone: (summary: string) => void): {
+        done: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            summary: string;
+            details?: string;
+        }, {
+            success: boolean;
+            message: string;
+            summary?: undefined;
+        } | {
+            success: boolean;
+            summary: any;
+            message?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        runCommand: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            command: any;
+        }, {
+            success: boolean;
+            message: string;
+            command?: undefined;
+            output?: undefined;
+        } | {
+            success: boolean;
+            command: any;
+            message: string;
+            output?: undefined;
+        } | {
+            success: boolean;
+            command: any;
+            output: string;
+            message?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+    };
+    tools(task: Task, onDone: (summary: string) => void): Promise<{
+        done: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            summary: string;
+            details?: string;
+        }, {
+            success: boolean;
+            message: string;
+            summary?: undefined;
+        } | {
+            success: boolean;
+            summary: any;
+            message?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        runCommand: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            command: any;
+        }, {
+            success: boolean;
+            message: string;
+            command?: undefined;
+            output?: undefined;
+        } | {
+            success: boolean;
+            command: any;
+            message: string;
+            output?: undefined;
+        } | {
+            success: boolean;
+            command: any;
+            output: string;
+            message?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+    }>;
+    processSupervisorInterrupt(userMessage: string, activeTest: Test): Promise<SupervisorAction>;
+    processExecutionError(error: Error, activeTest: Test): Promise<ExecutionRecoveryAction>;
+    canCompleteWithoutDetails(): boolean;
+    handle(input: string, options?: {
+        reset?: boolean;
+    }): Promise<string | null>;
+}
+export default Captain;
+interface SupervisorAction {
+    action: 'inject' | 'stop' | 'pass' | 'skip';
+    message: string;
+}
+interface ExecutionRecoveryAction {
+    action: 'continue' | 'stop';
+    message: string;
+    recovered?: boolean;
+}