explorbot 0.1.31 → 0.2.0

package/dist/src/action.js

@@ -1,19 +1,17 @@
 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 { codeceptJSSandbox, hasPlaywrightCommands, playwrightSandbox, sanitizeCodeBlock } from "./utils/web-sandbox.js";
 import { safeFilename } from "./utils/strings.js";
 const debugLog = createDebug('explorbot:action');
 const CAPTURE_NAVIGATION_TRANSITION_ATTEMPTS = 3;
@@ -24,7 +22,6 @@ class Action {
     config;
     // action info
     action = null;
-    expectation = null;
     lastError = null;
     playwrightHelper;
     playwrightGroupId = null;
@@ -38,9 +35,6 @@ class Action {
         this.playwrightHelper = container.helpers('Playwright');
         this.recorder = recorder;
     }
-    async caputrePageWithScreenshot() {
-        return this.capturePageState({ includeScreenshot: true });
-    }
     async saveScreenshot() {
         const currentState = this.stateManager.getCurrentState();
         if (currentState?.screenshotFile)
@@ -58,7 +52,7 @@ class Action {
             return undefined;
         }
     }
-    async capturePageState({ includeScreenshot = false } = {}) {
+    async capturePageState({ includeScreenshot = false, codeBlock } = {}) {
         try {
             const currentState = this.stateManager.getCurrentState();
             const stateHash = currentState?.hash || 'screenshot';
@@ -145,11 +139,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);
@@ -272,21 +266,18 @@ class Action {
             }
             if (isPlaywright) {
                 const page = this.playwrightHelper.page;
-                const asyncFn = new Function('page', `return (async () => { ${sanitizedCode} })()`);
-                await asyncFn(page);
+                await playwrightSandbox(page, sanitizedCode);
                 await sleep(this.config.action?.delay || 500);
             }
             else {
-                const codeFunction = new Function('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.capturePageState({ codeBlock: codeString });
             this.actionResult = pageState;
             this.assertionSteps = assertionSteps;
         }
@@ -313,79 +304,15 @@ 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 = new Function('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) {
         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) {
@@ -399,12 +326,6 @@ class Action {
     getActor() {
         return this.actor;
     }
-    setActor(actor) {
-        this.actor = actor;
-    }
-    getCurrentState() {
-        return this.actionResult;
-    }
     getActionResult() {
         return this.actionResult;
     }
@@ -423,6 +344,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,22 +366,6 @@ async function captureTitle(page, actor) {
         return actor.grabTitle();
     return '';
 }
-function sanitizeCodeBlock(code) {
-    return code
-        .split('\n')
-        .map((line) => line.trim())
-        .filter((line) => line.startsWith('I.') || line.startsWith('page.') || line.startsWith('await '))
-        .join('\n');
-}
-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/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/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,11 @@ 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 agentTools = createAgentTools({
                 explorer,
                 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 {

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

@@ -0,0 +1,141 @@
+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';
+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;
+    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;
+}

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;
@@ -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();
@@ -126,13 +126,6 @@ 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();
         if (!state) {
@@ -141,15 +134,7 @@ export class Captain extends CaptainBase {
         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);

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

@@ -0,0 +1,28 @@
+import type { ModelMessage } from 'ai';
+export interface ToolExecution {
+    toolName: string;
+    input: any;
+    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 {
+    messages: ModelMessage[];
+    model: any;
+    protectedPrefixCount: number;
+    autoTrimRules: Map<string, number>;
+    constructor(messages?: ModelMessage[], model?: any);
+    protectPrefix(count: number): void;
+    addUserText(text: 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;
+    getToolExecutions(): ToolExecution[];
+}

package/dist/src/ai/conversation.js

@@ -1,20 +1,22 @@
+export function toToolExecution(toolName, input, rawOutput) {
+    let output = rawOutput;
+    if (rawOutput?.type === 'json' && rawOutput?.value)
+        output = rawOutput.value;
+    return { toolName, input, output, wasSuccessful: output?.success !== false };
+}
 export function toolExecutionLabel(input) {
     return input?.explanation || input?.assertion || input?.reason || input?.request || '';
 }
 const AUTO_COMPACT_ARIA_CHANGES_CUTOFF = 500;
 const AUTO_COMPACT_TARGETED_HTML_CUTOFF = 500;
 export class Conversation {
-    id;
     messages;
     model;
-    telemetryFunctionId;
     protectedPrefixCount = 0;
     autoTrimRules;
-    constructor(messages = [], model, telemetryFunctionId) {
-        this.id = this.generateId();
+    constructor(messages = [], model) {
         this.messages = messages;
         this.model = model || '';
-        this.telemetryFunctionId = telemetryFunctionId;
         this.autoTrimRules = new Map();
     }
     protectPrefix(count) {
@@ -26,17 +28,6 @@ export class Conversation {
             content: this.applyAutoTrim(text),
         });
     }
-    addUserImage(image) {
-        if (!image || image.trim() === '') {
-            console.warn('Warning: Attempting to add empty image to conversation');
-            return;
-        }
-        const imageData = image.startsWith('data:') ? image : `data:image/png;base64,${image}`;
-        this.messages.push({
-            role: 'user',
-            content: [{ type: 'file', mediaType: 'image/png', data: imageData }],
-        });
-    }
     addAssistantText(text) {
         // Skip empty or whitespace-only messages
         if (!text || text.trim() === '') {
@@ -61,7 +52,7 @@ export class Conversation {
         return '';
     }
     clone() {
-        return new Conversation([...this.messages], this.model, this.telemetryFunctionId);
+        return new Conversation([...this.messages], this.model);
     }
     cleanupTag(tagName, replacement, keepLast = 0) {
         const escapedTag = tagName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -190,9 +181,6 @@ export class Conversation {
         }
         return result;
     }
-    generateId() {
-        return `conv_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    }
     getToolExecutions() {
         const toolCalls = new Map();
         for (const message of this.messages) {
@@ -215,14 +203,7 @@ export class Conversation {
             for (const part of message.content) {
                 if (part.type !== 'tool-result')
                     continue;
-                const rawOutput = part.output;
-                const output = rawOutput?.type === 'json' && rawOutput?.value ? rawOutput.value : rawOutput;
-                executions.push({
-                    toolName: part.toolName,
-                    input: toolCalls.get(part.toolCallId) || {},
-                    output,
-                    wasSuccessful: output?.success !== false,
-                });
+                executions.push(toToolExecution(part.toolName, toolCalls.get(part.toolCallId) || {}, part.output));
             }
         }
         return executions;