explorbot 0.1.30 → 0.1.32-beta.1

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

@@ -0,0 +1,31 @@
+import type { ModelMessage } from 'ai';
+export interface ToolExecution {
+    toolName: string;
+    input: any;
+    output: any;
+    wasSuccessful: boolean;
+}
+export declare function toolExecutionLabel(input: Record<string, any> | undefined): string;
+export declare class Conversation {
+    id: string;
+    messages: ModelMessage[];
+    model: any;
+    telemetryFunctionId?: string;
+    protectedPrefixCount: number;
+    autoTrimRules: Map<string, number>;
+    constructor(messages?: ModelMessage[], model?: any, telemetryFunctionId?: string);
+    protectPrefix(count: number): void;
+    addUserText(text: string): void;
+    addUserImage(image: string): void;
+    addAssistantText(text: string): void;
+    getLastMessage(): string;
+    clone(): Conversation;
+    cleanupTag(tagName: string, replacement: string, keepLast?: number): void;
+    autoTrimTag(tagName: string, maxLength: number): void;
+    compactToolResults(keepLastN: number): void;
+    markLastMessageCacheable(): void;
+    hasTag(tagName: string, lastN?: number): boolean;
+    applyAutoTrim(text: string): string;
+    generateId(): string;
+    getToolExecutions(): ToolExecution[];
+}

package/dist/src/ai/conversation.js

@@ -34,7 +34,7 @@ export class Conversation {
         const imageData = image.startsWith('data:') ? image : `data:image/png;base64,${image}`;
         this.messages.push({
             role: 'user',
-            content: [{ type: 'image', image: imageData }],
+            content: [{ type: 'file', mediaType: 'image/png', data: imageData }],
         });
     }
     addAssistantText(text) {

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

@@ -0,0 +1,161 @@
+import { ActionResult } from '../action-result.js';
+import type { ExperienceTracker } from '../experience-tracker.js';
+import type Explorer from '../explorer.js';
+import type { KnowledgeTracker } from '../knowledge-tracker.js';
+import { Plan, Test } from '../test-plan.js';
+import { HooksRunner } from '../utils/hooks-runner.js';
+import { WebElement } from '../utils/web-element.js';
+import type { Agent } from './agent.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';
+interface ComponentInfo {
+    id: string;
+    name: string;
+    role: string;
+    locator: string;
+    preferredCode: string;
+    eidx: string;
+    description: string;
+    html: string;
+    text: string;
+    tag: string;
+    classes: string[];
+    attrs: Record<string, string>;
+    context: string;
+    variant: string;
+    placeholder: string;
+    disabled: boolean;
+    ariaMatches: string[];
+}
+interface InteractionResult {
+    componentId: string;
+    component: string;
+    action: string;
+    result: 'success' | 'failed' | 'unknown';
+    description: string;
+    code?: string;
+}
+interface ComponentTest extends Test {
+    component?: ComponentInfo;
+    interactions?: InteractionResult[];
+}
+interface DrillOptions {
+    knowledgePath?: string;
+    maxComponents?: number;
+    interactive?: boolean;
+}
+export declare class Driller extends TaskAgent implements Agent {
+    readonly ACTION_TOOLS: string[];
+    emoji: string;
+    explorer: Explorer;
+    provider: Provider;
+    navigator: Navigator;
+    hooksRunner: HooksRunner;
+    currentPlan?: Plan;
+    currentConversation: Conversation | null;
+    allResults: InteractionResult[];
+    verifiedAction: {
+        componentId: string;
+        toolName: string;
+        code?: string;
+        canonicalCode?: string;
+    } | null;
+    pendingNestedContext: string | null;
+    MAX_COMPONENT_ITERATIONS: number;
+    constructor(explorer: Explorer, provider: Provider, navigator: Navigator);
+    getNavigator(): Navigator;
+    getExperienceTracker(): ExperienceTracker;
+    getKnowledgeTracker(): KnowledgeTracker;
+    getProvider(): Provider;
+    getSystemMessage(component?: ComponentInfo): string;
+    drill(opts?: DrillOptions): Promise<Plan>;
+    captureAnnotatedState(): Promise<ActionResult>;
+    collectComponents(state: ActionResult, maxComponents: number): Promise<ComponentInfo[]>;
+    toComponentInfo(element: WebElement, ariaNodes: Array<Record<string, unknown>>): ComponentInfo;
+    drillComponent(test: ComponentTest, originalState: ActionResult, interactive: boolean): Promise<void>;
+    buildComponentPrompt(originalState: ActionResult, component: ComponentInfo): Promise<string>;
+    buildContextUpdate(currentState: ActionResult, component: ComponentInfo): Promise<string>;
+    createDrillFlowTools(originalState: ActionResult, test: ComponentTest, interactive: boolean): {
+        drill_record: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            action: any;
+            result: any;
+            code: any;
+        }, {
+            success: boolean;
+            message: string;
+            recorded?: undefined;
+        } | {
+            success: boolean;
+            recorded: string;
+            message?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        drill_done: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            summary: any;
+        }, {
+            success: boolean;
+            message: string;
+            summary?: undefined;
+            recorded?: undefined;
+        } | {
+            success: boolean;
+            summary: any;
+            recorded: number;
+            message?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        drill_skip: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            reason: any;
+        }, {
+            success: boolean;
+            message: string;
+            skipped?: undefined;
+        } | {
+            success: boolean;
+            skipped: string;
+            message?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        drill_restore: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            reason: any;
+        }, {
+            success: boolean;
+            url: string;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        drill_ask: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            question: any;
+        }, {
+            success: boolean;
+            message: string;
+            skipped?: undefined;
+            userSuggestion?: undefined;
+            instruction?: undefined;
+        } | {
+            success: boolean;
+            skipped: boolean;
+            message?: undefined;
+            userSuggestion?: undefined;
+            instruction?: undefined;
+        } | {
+            success: boolean;
+            userSuggestion: string;
+            instruction: string;
+            message?: undefined;
+            skipped?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+    };
+    restoreOriginalState(originalState: ActionResult, reason: string): Promise<void>;
+    saveToExperience(state: ActionResult, results: InteractionResult[]): Promise<void>;
+    createVerifiedActionTools(baseTools: Record<string, any>, component: ComponentInfo): Record<string, any>;
+    hasVerifiedAction(componentId: string): boolean;
+    detectNestedOverlayContext(component: ComponentInfo, result: any): Promise<string | null>;
+    getVisibleOverlayHtml(): Promise<string>;
+    getComponentScopeHtml(component: ComponentInfo, originalState: ActionResult): Promise<string>;
+    saveToKnowledge(knowledgePath: string, state: ActionResult, results: InteractionResult[]): Promise<void>;
+    generateKnowledgeContent(state: ActionResult, interactions: InteractionResult[]): string;
+    logSummary(): void;
+    getCurrentPlan(): Plan | undefined;
+    getConversation(): Conversation | null;
+}
+export declare function buildCanonicalClickCode(component: ComponentInfo): string;
+export declare function formatExperienceTitle(interaction: InteractionResult): string;
+export {};

package/dist/src/ai/experience-compactor.d.ts

@@ -0,0 +1,53 @@
+import { type ExperienceFile, type ExperienceTracker } from '../experience-tracker.js';
+import type { Agent } from './agent.js';
+import type { Provider } from './provider.js';
+export type { ExperienceFile };
+interface MergeGroup {
+    pattern: string;
+    files: ExperienceFile[];
+}
+export declare class ExperienceCompactor implements Agent {
+    emoji: string;
+    provider: Provider;
+    experienceTracker: ExperienceTracker;
+    MAX_LENGTH: number;
+    constructor(provider: Provider, experienceTracker: ExperienceTracker);
+    compactExperience(experience: string): Promise<string>;
+    stripNonUsefulEntries(content: string): string;
+    isRecent(file: ExperienceFile): boolean;
+    reviewExperienceQuality(content: string, context: {
+        url?: string;
+        title?: string;
+    }): Promise<string>;
+    compactAllExperiences(): Promise<{
+        merged: number;
+        compacted: number;
+    }>;
+    autocompact(): Promise<{
+        merged: number;
+        compacted: number;
+    }>;
+    generalizeDynamicUrls(): number;
+    compactFiles(files: ExperienceFile[], options?: {
+        skipSmall?: boolean;
+    }): Promise<number>;
+    mergeSimilarExperiences(options?: {
+        onlyDynamic?: boolean;
+    }): Promise<number>;
+    identifyMergeGroups(files: ExperienceFile[]): Promise<MergeGroup[]>;
+    askAiForMergeDecisions(urls: string[]): Promise<{
+        urls: string[];
+        pattern: string;
+    }[]>;
+    buildMergePrompt(urls: string[]): string;
+    mergeExperienceGroup(group: MergeGroup): Promise<void>;
+    getSystemPrompt(): string;
+    buildCompactionPrompt(content: string): string;
+    buildReviewPrompt(sections: Array<{
+        title: string;
+        raw: string;
+    }>, context: {
+        url?: string;
+        title?: string;
+    }): string;
+}

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

@@ -0,0 +1,90 @@
+import type { ApiClient } from '../api/api-client.js';
+import type { RequestStore } from '../api/request-store.js';
+export declare function createFishermanTools(apiClient: ApiClient, requestStore: RequestStore, opts: {
+    spec?: any;
+    baseEndpoint?: string;
+}): {
+    tools: {
+        getEndpointSpec: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            method: any;
+            path: any;
+        }, {
+            source: string;
+            method: string;
+            path: string;
+            status: number;
+            requestBody: any;
+            definition?: undefined;
+            error?: undefined;
+        } | {
+            source: string;
+            definition: string;
+            method?: undefined;
+            path?: undefined;
+            status?: undefined;
+            requestBody?: undefined;
+            error?: undefined;
+        } | {
+            source: string;
+            error: any;
+            method?: undefined;
+            path?: undefined;
+            status?: undefined;
+            requestBody?: undefined;
+            definition?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        request: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<any, {
+            success: boolean;
+            error: string;
+            status?: undefined;
+            statusText?: undefined;
+            errorPreview?: undefined;
+        } | {
+            success: boolean;
+            status: number;
+            statusText: string;
+            errorPreview: string;
+            error?: undefined;
+        } | {
+            success: boolean;
+            status: number;
+            error?: undefined;
+            statusText?: undefined;
+            errorPreview?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        finish: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            summary: string;
+            created: {
+                type: string;
+                id?: string | number;
+                title?: string;
+            }[];
+            failed?: {
+                type: string;
+                reason: string;
+            }[];
+        }, {
+            finished: boolean;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        stop: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            reason: any;
+        }, {
+            stopped: boolean;
+        }, import("@ai-sdk/provider-utils").Context>>;
+    };
+    getResult: () => FishermanResult;
+    isFinished: () => boolean;
+};
+export interface FishermanResult {
+    success: boolean;
+    summary: string;
+    created: Array<{
+        type: string;
+        id?: string | number;
+        title?: string;
+    }>;
+    failed: Array<{
+        type: string;
+        reason: string;
+    }>;
+}

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

@@ -0,0 +1,30 @@
+import type { ApiClient } from '../api/api-client.js';
+import type { RequestStore } from '../api/request-store.js';
+import type { Agent } from './agent.js';
+import { type FishermanResult } from './fisherman-tools.js';
+import type { Provider } from './provider.js';
+export declare class Fisherman implements Agent {
+    emoji: string;
+    provider: Provider;
+    apiClient: ApiClient;
+    requestStore: RequestStore;
+    specLoader: () => Promise<any | null>;
+    cookieProvider: () => Promise<Record<string, string>>;
+    configHeaders: Record<string, string>;
+    sessionName?: string;
+    baseEndpoint: string;
+    spec: any | null;
+    mode: 'replicate' | 'achieve' | 'disabled';
+    hasApiConfig: boolean;
+    constructor(provider: Provider, apiClient: ApiClient, requestStore: RequestStore, specLoader: () => Promise<any | null>, baseEndpoint: string, cookieProvider: () => Promise<Record<string, string>>, configHeaders?: Record<string, string>, hasApiConfig?: boolean);
+    isAvailable(): boolean;
+    getMode(): string;
+    ensureReady(scopeUrl?: string): Promise<void>;
+    getEndpointList(scopeUrl?: string): string;
+    prepareData(instructions: string, scopeUrl?: string, sessionName?: string): Promise<FishermanResult>;
+    detectMode(scopeUrl?: string): Promise<void>;
+    refreshAuth(): Promise<void>;
+    buildEndpointList(scopeUrl?: string): string;
+    buildSystemPrompt(endpointList: string, toolNames: string[], scopeUrl?: string): string;
+    buildTaskPrompt(instructions: string): string;
+}

package/dist/src/ai/historian/codeceptjs.d.ts

@@ -0,0 +1,15 @@
+import type { Plan } from '../../test-plan.js';
+import type { Conversation } from '../conversation.js';
+import type { Constructor } from './mixin.js';
+export interface CodeceptJSMethods {
+    toCode(conversation: Conversation, scenario: string): string;
+    saveCodeceptPlanToFile(plan: Plan): string;
+}
+export declare function WithCodeceptJS<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        savedFiles: Set<string>;
+        toCode(conversation: Conversation, scenario: string): string;
+        saveCodeceptPlanToFile(plan: Plan): string;
+        getKnowledgeLines(url: string, indent?: string): string[];
+    };
+} & T;

package/dist/src/ai/historian/experience.d.ts

@@ -0,0 +1,40 @@
+import { ActionResult } from '../../action-result.js';
+import { ExperienceTracker, type SessionStep } from '../../experience-tracker.js';
+import type { Reporter } from '../../reporter.js';
+import type { StateManager } from '../../state-manager.js';
+import { type Task, Test } from '../../test-plan.js';
+import type { Conversation, ToolExecution } from '../conversation.js';
+import type { Provider } from '../provider.js';
+import { type Constructor } from './mixin.js';
+export interface ExperienceMethods {
+    saveSession(task: Task, initialState: ActionResult, conversation: Conversation): Promise<void>;
+}
+export declare function WithExperience<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        provider: Provider;
+        experienceTracker: ExperienceTracker;
+        reporter: Reporter | undefined;
+        stateManager: StateManager | undefined;
+        isPlaywrightFramework: () => boolean;
+        toCode: (conversation: Conversation, scenario: string) => string;
+        toPlaywrightCode: (conversation: Conversation, scenario: string) => Promise<string>;
+        stopScreencast: () => Promise<void>;
+        saveSession(task: Task, initialState: ActionResult, conversation: Conversation): Promise<void>;
+        reportSession(test: Test, steps: SessionStep[]): Promise<void>;
+        extractSteps(toolExecutions: ToolExecution[]): Promise<SessionStep[]>;
+        hasRelevantFlowExperience(state: ActionResult): boolean;
+        extractPassedCodeceptSteps(task: Task): SessionStep[];
+        curateFlow(steps: SessionStep[], task: Task, initialState: ActionResult): Promise<string>;
+        renderFlowFromSuccessfulSteps(steps: SessionStep[], task: Task): string;
+        detectRetryPatterns(toolExecutions: ToolExecution[], initialState: ActionResult): Promise<void>;
+        analyzeDiscoveries(stepsWithDiffs: Array<{
+            step: SessionStep;
+            ariaDiff: string | null;
+        }>): Promise<void>;
+        buildDiscoveryPrompt(stepsWithDiffs: Array<{
+            step: SessionStep;
+            ariaDiff: string | null;
+        }>): string;
+        extractVisitedUrls(toolExecutions: ToolExecution[], initialUrl: string): string[];
+    };
+} & T;

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

@@ -0,0 +1,2 @@
+export type Constructor<T = object> = new (...args: any[]) => T;
+export declare const debugLog: (...args: any[]) => void;

package/dist/src/ai/historian/playwright.d.ts

@@ -0,0 +1,20 @@
+import { type PlaywrightRecorder } from '../../playwright-recorder.js';
+import type { Plan } from '../../test-plan.js';
+import type { Conversation } from '../conversation.js';
+import type { Constructor } from './mixin.js';
+export interface PlaywrightMethods {
+    toPlaywrightCode(conversation: Conversation, scenario: string): Promise<string>;
+    savePlaywrightPlanToFile(plan: Plan): string;
+}
+export declare function WithPlaywright<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        playwright: {
+            recorder: PlaywrightRecorder;
+            helper: any;
+        } | undefined;
+        savedFiles: Set<string>;
+        toPlaywrightCode(conversation: Conversation, scenario: string): Promise<string>;
+        savePlaywrightPlanToFile(plan: Plan): string;
+        getPlaywrightKnowledgeLines(url: string, indent?: string): string[];
+    };
+} & T;

package/dist/src/ai/historian/screencast.d.ts

@@ -0,0 +1,32 @@
+import type { ExplorbotConfig } from '../../config.js';
+import type { PlaywrightRecorder } from '../../playwright-recorder.js';
+import { type Constructor } from './mixin.js';
+export interface ScreencastMethods {
+    attachScreencast(): void;
+    isScreencastActive(): boolean;
+    stopScreencast(): Promise<void>;
+}
+export declare function WithScreencast<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        config: ExplorbotConfig | undefined;
+        savedFiles: Set<string>;
+        playwright: {
+            recorder: PlaywrightRecorder;
+            helper: any;
+        } | undefined;
+        screencastPage: any;
+        screencastActive: boolean;
+        screencastPath: string | null;
+        screencastListenersInstalled: boolean;
+        screencastTask: any;
+        screencastLastChapter: string | null;
+        onTestBefore?: (test: any) => void;
+        onStepPassed?: (step: any) => void;
+        onTestAfter?: () => void;
+        isScreencastActive(): boolean;
+        attachScreencast(): void;
+        startScreencast(test: any): Promise<void>;
+        emitChapter(_step: any): Promise<void>;
+        stopScreencast(): Promise<void>;
+    };
+} & T;

package/dist/src/ai/historian/utils.d.ts

@@ -0,0 +1,4 @@
+import type { ToolExecution } from '../conversation.js';
+export { isNonReusableCode, stripComments } from '../../utils/step-analyzer.js';
+export declare function escapeString(str: string): string;
+export declare function getExecutionLabel(exec: ToolExecution, fallback?: string): string;

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

@@ -0,0 +1,108 @@
+import type { ExplorbotConfig } from '../config.js';
+import { ExperienceTracker } from '../experience-tracker.js';
+import type { PlaywrightRecorder } from '../playwright-recorder.js';
+import type { Reporter } from '../reporter.js';
+import type { StateManager } from '../state-manager.js';
+import type { Plan } from '../test-plan.js';
+import { type CodeceptJSMethods } from './historian/codeceptjs.js';
+import { type ExperienceMethods } from './historian/experience.js';
+import { type PlaywrightMethods } from './historian/playwright.js';
+import { type ScreencastMethods } from './historian/screencast.js';
+import type { Provider } from './provider.js';
+export { isNonReusableCode } from '../utils/step-analyzer.js';
+declare const HistorianBase: {
+    new (...args: any[]): {
+        config: ExplorbotConfig | undefined;
+        savedFiles: Set<string>;
+        playwright: {
+            recorder: PlaywrightRecorder;
+            helper: any;
+        };
+        screencastPage: any;
+        screencastActive: boolean;
+        screencastPath: string | null;
+        screencastListenersInstalled: boolean;
+        screencastTask: any;
+        screencastLastChapter: string | null;
+        onTestBefore?: (test: any) => void;
+        onStepPassed?: (step: any) => void;
+        onTestAfter?: () => void;
+        isScreencastActive(): boolean;
+        attachScreencast(): void;
+        startScreencast(test: any): Promise<void>;
+        emitChapter(_step: any): Promise<void>;
+        stopScreencast(): Promise<void>;
+    };
+} & {
+    new (...args: any[]): {
+        playwright: {
+            recorder: PlaywrightRecorder;
+            helper: any;
+        };
+        savedFiles: Set<string>;
+        toPlaywrightCode(conversation: import("./conversation.js").Conversation, scenario: string): Promise<string>;
+        savePlaywrightPlanToFile(plan: Plan): string;
+        getPlaywrightKnowledgeLines(url: string, indent?: string): string[];
+    };
+} & {
+    new (...args: any[]): {
+        savedFiles: Set<string>;
+        toCode(conversation: import("./conversation.js").Conversation, scenario: string): string;
+        saveCodeceptPlanToFile(plan: Plan): string;
+        getKnowledgeLines(url: string, indent?: string): string[];
+    };
+} & {
+    new (...args: any[]): {
+        provider: Provider;
+        experienceTracker: ExperienceTracker;
+        reporter: Reporter | undefined;
+        stateManager: StateManager | undefined;
+        isPlaywrightFramework: () => boolean;
+        toCode: (conversation: import("./conversation.js").Conversation, scenario: string) => string;
+        toPlaywrightCode: (conversation: import("./conversation.js").Conversation, scenario: string) => Promise<string>;
+        stopScreencast: () => Promise<void>;
+        saveSession(task: import("../test-plan.js").Task, initialState: import("../action-result.js").ActionResult, conversation: import("./conversation.js").Conversation): Promise<void>;
+        reportSession(test: import("../test-plan.js").Test, steps: import("../experience-tracker.js").SessionStep[]): Promise<void>;
+        extractSteps(toolExecutions: import("./conversation.js").ToolExecution[]): Promise<import("../experience-tracker.js").SessionStep[]>;
+        hasRelevantFlowExperience(state: import("../action-result.js").ActionResult): boolean;
+        extractPassedCodeceptSteps(task: import("../test-plan.js").Task): import("../experience-tracker.js").SessionStep[];
+        curateFlow(steps: import("../experience-tracker.js").SessionStep[], task: import("../test-plan.js").Task, initialState: import("../action-result.js").ActionResult): Promise<string>;
+        renderFlowFromSuccessfulSteps(steps: import("../experience-tracker.js").SessionStep[], task: import("../test-plan.js").Task): string;
+        detectRetryPatterns(toolExecutions: import("./conversation.js").ToolExecution[], initialState: import("../action-result.js").ActionResult): Promise<void>;
+        analyzeDiscoveries(stepsWithDiffs: {
+            step: import("../experience-tracker.js").SessionStep;
+            ariaDiff: string | null;
+        }[]): Promise<void>;
+        buildDiscoveryPrompt(stepsWithDiffs: {
+            step: import("../experience-tracker.js").SessionStep;
+            ariaDiff: string | null;
+        }[]): string;
+        extractVisitedUrls(toolExecutions: import("./conversation.js").ToolExecution[], initialUrl: string): string[];
+    };
+} & (new (...args: any[]) => object);
+export interface Historian extends ExperienceMethods, CodeceptJSMethods, PlaywrightMethods, ScreencastMethods {
+}
+export declare class Historian extends HistorianBase {
+    provider: Provider;
+    experienceTracker: ExperienceTracker;
+    reporter: Reporter | undefined;
+    stateManager: StateManager | undefined;
+    config: ExplorbotConfig | undefined;
+    playwright: {
+        recorder: PlaywrightRecorder;
+        helper: any;
+    } | undefined;
+    savedFiles: Set<string>;
+    constructor(provider: Provider, experienceTracker?: ExperienceTracker, reporter?: Reporter, stateManager?: StateManager, config?: ExplorbotConfig, playwright?: {
+        recorder: PlaywrightRecorder;
+        helper: any;
+    });
+    isPlaywrightFramework(): boolean;
+    getSavedFiles(): string[];
+    savePlanToFile(plan: Plan): string;
+    rewriteScenarioInFile(filePath: string, healedSteps: Array<{
+        test: string;
+        original: string;
+        healed: string;
+    }>): void;
+}

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

@@ -0,0 +1,56 @@
+import { ActionResult } from '../action-result.js';
+import type Action from '../action.js';
+import { ExperienceTracker } from '../experience-tracker.js';
+import Explorer from '../explorer.js';
+import { KnowledgeTracker } from '../knowledge-tracker.js';
+import { HooksRunner } from '../utils/hooks-runner.js';
+import type { Agent } from './agent.js';
+import { ExperienceCompactor } from './experience-compactor.js';
+import type { Provider } from './provider.js';
+declare class Navigator implements Agent {
+    emoji: string;
+    provider: Provider;
+    experienceCompactor: ExperienceCompactor;
+    knowledgeTracker: KnowledgeTracker;
+    experienceTracker: ExperienceTracker;
+    hooksRunner: HooksRunner;
+    MAX_ATTEMPTS: number;
+    systemPrompt: string;
+    freeSailSystemPrompt: string;
+    explorer: Explorer;
+    constructor(explorer: Explorer, provider: Provider, experienceCompactor: ExperienceCompactor, experienceTracker?: ExperienceTracker);
+    get verifyAttempts(): number;
+    get verifyTimeout(): number;
+    getBaseOrigin(): string | null;
+    getComparableCurrentUrl(stateManager: any, expectedUrl: string): string;
+    isSameExpectedOrigin(expectedUrl: string, stateManager: any): boolean;
+    isOnExpectedPage(expectedUrl: string, stateManager: any): boolean;
+    visit(url: string): Promise<void>;
+    visitOnce(url: string): Promise<void>;
+    resolveState(message: string, actionResult: ActionResult, opts?: {
+        action?: Action;
+        expectedUrl?: string;
+    }): Promise<boolean>;
+    buildExperienceTools(): {
+        learnExperience: unknown;
+    } | undefined;
+    freeSail(opts?: {
+        strategy?: 'deep' | 'shallow';
+        scope?: string;
+        visitedUrls?: Set<string>;
+    }, actionResult?: ActionResult): Promise<{
+        target: string;
+        reason: string;
+    } | null>;
+    verifyState(message: string, actionResult: ActionResult): Promise<{
+        verified: boolean;
+        successfulCodes: string[];
+        assertionSteps: Array<{
+            name: string;
+            args: any[];
+        }>;
+        totalAttempted: number;
+    }>;
+    checkAlreadyVerified(aiResponse: string, actionResult: ActionResult): boolean;
+}
+export { Navigator };