explorbot 0.1.32-beta.1 → 0.2.1

package/dist/src/action.js

@@ -1,20 +1,18 @@
 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 { ActionResult } from './action-result.js';
 import { clearActivity, setActivity } from "./activity.js";
 import { ConfigParser, outputPath } from './config.js';
 import { Observability } from "./observability.js";
-import { isFatalBrowserError, isNavigationTransitionError } from "./utils/browser-errors.js";
-import { htmlCombinedSnapshot, minifyHtml } from './utils/html.js';
+import { browserErrorMessage, isFatalBrowserError, isNavigationTransitionError } from "./utils/browser-errors.js";
+import { captureHtmlForSnapshot, htmlCombinedSnapshot, minifyHtml } from './utils/html.js';
 import { createDebug, setStepSpanParent, tag } from './utils/logger.js';
-import { waitForPageReadiness } from "./utils/page-readiness.js";
+import { sleep, waitForPageReadiness } from "./utils/page-readiness.js";
 import { safeFilename } from "./utils/strings.js";
+import { codeceptJSSandbox, hasPlaywrightCommands, playwrightSandbox, sanitizeCodeBlock } from "./utils/web-sandbox.js";
 const debugLog = createDebug('explorbot:action');
 const CAPTURE_NAVIGATION_TRANSITION_ATTEMPTS = 3;
 class Action {
@@ -24,22 +22,20 @@ class Action {
     config;
     // action info
     action = null;
-    expectation = null;
     lastError = null;
     playwrightHelper;
     playwrightGroupId = null;
     assertionSteps = [];
     recorder;
+    recovery;
     mainDocumentStatus = undefined;
-    constructor(actor, stateManager, recorder) {
+    constructor(actor, stateManager, recorder, recovery) {
         this.actor = actor;
         this.stateManager = stateManager;
         this.config = ConfigParser.getInstance().getConfig();
         this.playwrightHelper = container.helpers('Playwright');
         this.recorder = recorder;
-    }
-    async caputrePageWithScreenshot() {
-        return this.capturePageState({ includeScreenshot: true });
+        this.recovery = recovery || ((fn) => fn());
     }
     async saveScreenshot() {
         const currentState = this.stateManager.getCurrentState();
@@ -58,7 +54,13 @@ class Action {
             return undefined;
         }
     }
-    async capturePageState({ includeScreenshot = false } = {}) {
+    async capturePageState(opts = {}) {
+        return this.recovery(() => this.captureOnce(opts));
+    }
+    async execute(code) {
+        return this.recovery(() => this.executeOnce(code));
+    }
+    async captureOnce({ includeScreenshot = false, codeBlock } = {}) {
         try {
             const currentState = this.stateManager.getCurrentState();
             const stateHash = currentState?.hash || 'screenshot';
@@ -145,11 +147,11 @@ 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);
@@ -249,7 +251,7 @@ class Action {
             return [];
         }
     }
-    async execute(code) {
+    async executeOnce(code) {
         let error = null;
         setActivity('🔎 Browsing...', 'action');
         let codeString = code.replace(/^\(I\) => /, '').trim();
@@ -272,21 +274,18 @@ 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;
         }
@@ -313,98 +312,37 @@ class Action {
         }
         return this;
     }
-    async expect(codeOrFunction) {
-        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;
-            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;
-            await recorder.reset();
-            await recorder.start();
-            debugLog('Expectation failed:', errorToString(err));
-        }
-        finally {
-            clearActivity();
-        }
-        return this;
-    }
-    async waitForInteraction() {
-        // start with basic approach
-        await this.actor.wait(0.5);
-        return this;
-    }
-    async attempt(codeBlock, originalMessage, experience = true) {
+    async attempt(codeBlock, originalMessage) {
+        const wasInFrame = !!this.playwrightHelper.frame;
         try {
             debugLog('Resolution attempt...');
             setActivity('🦾 Acting in browser...', '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;
             if (isFatalBrowserError(error))
                 throw error;
+            if (!wasInFrame)
+                await this.exitIframe().catch(() => { });
             debugLog(`Attempt failed: ${codeBlock}: ${errorToString(error) || this.lastError?.toString()}`);
             return false;
         }
     }
+    async exitIframe() {
+        if (!this.playwrightHelper.frame)
+            return;
+        debugLog('Switching to main frame');
+        await this.playwrightHelper.switchTo();
+    }
     getActor() {
         return this.actor;
     }
-    setActor(actor) {
-        this.actor = actor;
-    }
-    getCurrentState() {
-        return this.actionResult;
-    }
     getActionResult() {
         return this.actionResult;
     }
@@ -423,6 +361,13 @@ function errorToString(error) {
     return error.message || error.toString();
 }
 async function captureHtml(page, frame, actor) {
+    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)
@@ -438,27 +383,6 @@ async function captureTitle(page, actor) {
         return actor.grabTitle();
     return '';
 }
-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 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();
-        return trimmed.startsWith('page.') || trimmed.startsWith('await page.');
-    });
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 const ASSERTION_STEP_NAMES = new Set(['see', 'dontSee', 'seeElement', 'dontSeeElement', 'seeInField', 'dontSeeInField', 'seeInCurrentUrl', 'dontSeeInCurrentUrl']);
 const attachStepLogger = (target, assertionsTarget) => {
     const listener = (step, error) => {

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

@@ -1,3 +1,20 @@
+import type { RequestStore } from '../api/request-store.js';
+import type { ExplorbotConfig } from '../config.js';
+import type Explorer from '../explorer.js';
+import type { KnowledgeTracker } from '../knowledge-tracker.js';
+import type { PlaywrightRecorder } from '../playwright-recorder.js';
+import type { StateManager } from '../state-manager.js';
+import type { AIProvider } from './provider.js';
 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/dist/src/ai/captain/idle-mode.js

@@ -60,7 +60,7 @@ export function WithIdleMode(Base) {
                             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/dist/src/ai/captain/test-mode.js

@@ -144,7 +144,7 @@ export function WithTestMode(Base) {
                             states = t.states;
                         }
                         else {
-                            const stateManager = ctx.explorBot.getExplorer().getStateManager();
+                            const stateManager = ctx.explorBot.stateManager();
                             const history = stateManager.getStateHistory();
                             const seen = new Set();
                             states = history

package/dist/src/ai/captain/web-mode.js

@@ -1,7 +1,6 @@
 import { tool } from 'ai';
 import dedent from 'dedent';
 import { z } from 'zod';
-import { ActionResult } from "../../action-result.js";
 import { actionRule, locatorRule, sectionContextRule } from "../rules.js";
 import { createAgentTools, createCodeceptJSTools } from "../tools.js";
 import { debugLog } from "./mixin.js";
@@ -9,17 +8,12 @@ export function WithWebMode(Base) {
     return class extends Base {
         webModeTools(ctx) {
             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;
             return {
@@ -32,7 +26,7 @@ export function WithWebMode(Base) {
                         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 };
                         }
@@ -50,43 +44,38 @@ export function WithWebMode(Base) {
             - 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?.())
+                        const page = explorer.page;
+                        if (!page)
                             return { success: false, message: 'No browser page available. Try browser({ action: "recover" }) first.' };
                         if (action === 'evaluate') {
                             if (!code)

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

@@ -1,4 +1,4 @@
-import { ExperienceTracker } from '../experience-tracker.js';
+import type { 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';
@@ -55,8 +55,6 @@ export declare class Captain extends CaptainBase implements Agent {
     systemPrompt(): string;
     resetConversation(): Conversation;
     ensureConversation(): Conversation;
-    getConversation(): Conversation | null;
-    cleanConversation(): void;
     getPageContext(): Promise<string>;
     planSummary(): string;
     reinjectContextIfNeeded(conversation: Conversation, currentState: WebPageState): Promise<void>;

package/dist/src/ai/captain.js

@@ -2,8 +2,8 @@ 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 { Task } from "../test-plan.js";
+import { formatHeadings } from "../utils/context-formatter.js";
 import { HooksRunner } from "../utils/hooks-runner.js";
 import { startLogCapture, stopLogCapture, tag } from '../utils/logger.js';
 import { loop } from '../utils/loop.js';
@@ -28,7 +28,7 @@ export class Captain extends CaptainBase {
     constructor(explorBot) {
         super();
         this.explorBot = explorBot;
-        this.experienceTracker = new ExperienceTracker();
+        this.experienceTracker = explorBot.experienceTracker();
     }
     setCommandExecutor(fn, descriptions) {
         this.commandExecutor = fn;
@@ -37,7 +37,7 @@ export class Captain extends CaptainBase {
     getHooksRunner() {
         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;
     }
@@ -48,7 +48,7 @@ export class Captain extends CaptainBase {
         return this.experienceTracker;
     }
     getKnowledgeTracker() {
-        return this.explorBot.getExplorer().getKnowledgeTracker();
+        return this.explorBot.knowledgeTracker();
     }
     getProvider() {
         return this.explorBot.getProvider();
@@ -72,18 +72,17 @@ export class Captain extends CaptainBase {
     getMode() {
         const explorer = this.explorBot.getExplorer();
         const activeTest = explorer.activeTest;
-        const page = explorer.playwrightHelper?.page;
-        if (activeTest && (!page || page.isClosed?.()))
+        if (activeTest && !explorer.page)
             return 'heal';
         if (activeTest)
             return 'test';
-        if (explorer.getStateManager().getCurrentState())
+        if (this.explorBot.stateManager().getCurrentState())
             return 'web';
         return 'idle';
     }
     systemPrompt() {
         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 `
     <role>
@@ -126,30 +125,15 @@ export class Captain extends CaptainBase {
         }
         return this.conversation;
     }
-    getConversation() {
-        return this.conversation;
-    }
-    cleanConversation() {
-        this.conversation = null;
-        tag('info').log('Conversation cleaned');
-    }
     async getPageContext() {
-        const state = this.explorBot.getExplorer().getStateManager().getCurrentState();
+        const state = this.explorBot.stateManager().getCurrentState();
         if (!state) {
             return 'No page loaded';
         }
         const actionResult = ActionResult.fromState(state);
         const knowledge = this.getKnowledge(actionResult);
         const experience = this.getExperience(actionResult);
-        const headingLines = [];
-        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 = '';
         const cachedResearch = Researcher.getCachedResearch(state);
@@ -212,10 +196,9 @@ export class Captain extends CaptainBase {
     `;
     }
     async reinjectContextIfNeeded(conversation, currentState) {
-        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:
 
@@ -227,13 +210,8 @@ export class Captain extends CaptainBase {
         <page_aria>
         ${actionResult.getInteractiveARIA()}
         </page_aria>
-
-        <page_html>
-        ${html}
-        </page_html>
       `;
         conversation.addUserText(context);
-        return Promise.resolve();
     }
     coreTools(task, onDone) {
         return {
@@ -263,15 +241,8 @@ export class Captain extends CaptainBase {
             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"'),
@@ -329,7 +300,7 @@ export class Captain extends CaptainBase {
             recentToolSummary = execs.map((e) => `${e.toolName}: ${e.wasSuccessful ? 'ok' : 'fail'} ${truncateJson(e.input)}`).join('\n');
         }
         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']),
             message: z.string().describe('Message to pass to the tester or display to user'),
@@ -371,7 +342,7 @@ export class Captain extends CaptainBase {
     }
     async processExecutionError(error, activeTest) {
         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,
@@ -381,7 +352,7 @@ export class Captain extends CaptainBase {
         return (this.recentToolCalls || []).some(hasBrowserCompletionEvidence);
     }
     async handle(input, options = {}) {
-        const stateManager = this.explorBot.getExplorer().getStateManager();
+        const stateManager = this.explorBot.stateManager();
         const initialState = stateManager.getCurrentState();
         const conversation = options.reset ? this.resetConversation() : this.ensureConversation();
         let isDone = false;
@@ -441,6 +412,7 @@ export class Captain extends CaptainBase {
             const result = await this.explorBot.getProvider().invokeConversation(conversation, tools, {
                 maxToolRoundtrips: 5,
                 toolChoice: 'auto',
+                stopWhen: () => isDone,
             });
             if (!result) {
                 stop();

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

@@ -5,18 +5,16 @@ export interface ToolExecution {
     output: any;
     wasSuccessful: boolean;
 }
+export declare function toToolExecution(toolName: string, input: any, rawOutput: any): ToolExecution;
 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);
+    constructor(messages?: ModelMessage[], model?: any);
     protectPrefix(count: number): void;
     addUserText(text: string): void;
-    addUserImage(image: string): void;
     addAssistantText(text: string): void;
     getLastMessage(): string;
     clone(): Conversation;
@@ -26,6 +24,5 @@ export declare class Conversation {
     markLastMessageCacheable(): void;
     hasTag(tagName: string, lastN?: number): boolean;
     applyAutoTrim(text: string): string;
-    generateId(): string;
     getToolExecutions(): ToolExecution[];
 }