browser-use 0.0.1 → 0.1.0

package/dist/agent/gif.js

@@ -0,0 +1,215 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createCanvas, loadImage } from 'canvas';
+import GIFEncoder from 'gif-encoder-2';
+import { createLogger } from '../logging-config.js';
+import { PLACEHOLDER_4PX_SCREENSHOT } from '../browser/views.js';
+const logger = createLogger('browser_use.agent.gif');
+export const decode_unicode_escapes_to_utf8 = (text) => {
+    if (!text.includes('\\u')) {
+        return text;
+    }
+    try {
+        return Buffer.from(text, 'latin1').toString('utf8');
+    }
+    catch {
+        return text;
+    }
+};
+const asDataUrl = (screenshot) => {
+    if (!screenshot) {
+        return '';
+    }
+    return screenshot.startsWith('data:')
+        ? screenshot
+        : `data:image/png;base64,${screenshot}`;
+};
+const loadScreenshot = async (screenshot) => {
+    const normalized = asDataUrl(screenshot);
+    return loadImage(normalized);
+};
+const FONT_CANDIDATES = [
+    '"Microsoft YaHei"',
+    '"SimHei"',
+    '"SimSun"',
+    '"Noto Sans CJK SC"',
+    '"Arial"',
+    '"Helvetica"',
+    '"sans-serif"',
+];
+const pickFont = () => FONT_CANDIDATES.join(', ');
+const wrapText = (ctx, text, maxWidth) => {
+    const words = decode_unicode_escapes_to_utf8(text).split(/\s+/);
+    const lines = [];
+    let currentLine = '';
+    for (const word of words) {
+        const testLine = currentLine ? `${currentLine} ${word}` : word;
+        const metrics = ctx.measureText(testLine);
+        if (metrics.width > maxWidth && currentLine) {
+            lines.push(currentLine);
+            currentLine = word;
+        }
+        else {
+            currentLine = testLine;
+        }
+    }
+    if (currentLine) {
+        lines.push(currentLine);
+    }
+    return lines;
+};
+const drawRoundedRect = (ctx, x, y, width, height, radius, fillStyle) => {
+    ctx.save();
+    ctx.fillStyle = fillStyle;
+    ctx.beginPath();
+    ctx.moveTo(x + radius, y);
+    ctx.lineTo(x + width - radius, y);
+    ctx.quadraticCurveTo(x + width, y, x + width, y + radius);
+    ctx.lineTo(x + width, y + height - radius);
+    ctx.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
+    ctx.lineTo(x + radius, y + height);
+    ctx.quadraticCurveTo(x, y + height, x, y + height - radius);
+    ctx.lineTo(x, y + radius);
+    ctx.quadraticCurveTo(x, y, x + radius, y);
+    ctx.closePath();
+    ctx.fill();
+    ctx.restore();
+};
+const addOverlayToContext = (ctx, width, height, stepNumber, goalText, fontFamily, titleFontSize) => {
+    const margin = 40;
+    const textColor = 'rgba(255,255,255,1)';
+    const boxColor = 'rgba(0,0,0,0.7)';
+    ctx.save();
+    ctx.fillStyle = textColor;
+    ctx.font = `${titleFontSize}px ${fontFamily}`;
+    ctx.textBaseline = 'top';
+    const stepText = String(stepNumber);
+    const stepMetrics = ctx.measureText(stepText);
+    const stepWidth = stepMetrics.width;
+    const stepHeight = titleFontSize;
+    const stepX = margin;
+    const stepY = height - stepHeight - margin - 10;
+    drawRoundedRect(ctx, stepX - 20, stepY - 20, stepWidth + 40, stepHeight + 40, 15, boxColor);
+    ctx.fillText(stepText, stepX, stepY);
+    const maxWidth = width - margin * 4;
+    const lines = wrapText(ctx, goalText, maxWidth);
+    const totalHeight = lines.length * (titleFontSize + 10);
+    const goalX = (width - maxWidth) / 2;
+    const goalY = stepY - totalHeight - 80;
+    drawRoundedRect(ctx, goalX - 20, goalY - 20, maxWidth + 40, totalHeight + 40, 15, boxColor);
+    lines.forEach((line, idx) => {
+        ctx.fillText(line, goalX, goalY + idx * (titleFontSize + 10));
+    });
+    ctx.restore();
+};
+const addLogo = (ctx, width, image) => {
+    if (!image)
+        return;
+    ctx.save();
+    const margin = 20;
+    const targetHeight = 150;
+    const aspect = image.width / image.height || 1;
+    const targetWidth = targetHeight * aspect;
+    ctx.globalAlpha = 0.9;
+    // @ts-ignore - drawImage signature compatibility
+    ctx.drawImage(image, width - targetWidth - margin, margin, targetWidth, targetHeight);
+    ctx.restore();
+};
+const loadLogo = async () => {
+    try {
+        const logoPath = path.resolve('static/browser-use.png');
+        await fs.promises.access(logoPath, fs.constants.F_OK);
+        return await loadImage(logoPath);
+    }
+    catch {
+        return null;
+    }
+};
+const renderTaskFrame = (ctx, width, height, task, fontFamily, fontSize, lineSpacing, logo) => {
+    ctx.save();
+    ctx.fillStyle = '#000';
+    ctx.fillRect(0, 0, width, height);
+    ctx.fillStyle = '#fff';
+    ctx.font = `${fontSize}px ${fontFamily}`;
+    ctx.textAlign = 'center';
+    ctx.textBaseline = 'top';
+    const maxWidth = width - 280;
+    const lines = wrapText(ctx, task, maxWidth);
+    const totalHeight = lines.length * fontSize * lineSpacing;
+    let y = height / 2 - totalHeight / 2;
+    lines.forEach((line) => {
+        ctx.fillText(line, width / 2, y);
+        y += fontSize * lineSpacing;
+    });
+    ctx.restore();
+    addLogo(ctx, width, logo);
+};
+const drawScreenshotFrame = (ctx, width, height, image, stepNumber, goalText, fontFamily, titleFontSize, logo) => {
+    // @ts-ignore - drawImage signature compatibility
+    ctx.drawImage(image, 0, 0, width, height);
+    if (goalText) {
+        addOverlayToContext(ctx, width, height, stepNumber, goalText, fontFamily, titleFontSize);
+    }
+    addLogo(ctx, width, logo);
+};
+export const create_history_gif = async (task, history, { output_path = 'agent_history.gif', duration = 3000, show_goals = true, show_task = true, show_logo = false, font_size = 40, title_font_size = 56, goal_font_size = 44, line_spacing = 1.5, } = {}) => {
+    if (!history.history.length) {
+        logger.warn('No history to create GIF from');
+        return;
+    }
+    const screenshots = history.screenshots();
+    const firstRealScreenshot = screenshots.find((shot) => shot && shot !== PLACEHOLDER_4PX_SCREENSHOT);
+    if (!firstRealScreenshot) {
+        logger.warn('No valid screenshots found (all are placeholders)');
+        return;
+    }
+    const firstImage = await loadScreenshot(firstRealScreenshot);
+    const width = firstImage.width;
+    const height = firstImage.height;
+    const canvas = createCanvas(width, height);
+    const ctx = canvas.getContext('2d');
+    const encoder = new GIFEncoder(width, height);
+    await fs.promises.mkdir(path.dirname(path.resolve(output_path)), {
+        recursive: true,
+    });
+    const writeStream = fs.createWriteStream(path.resolve(output_path));
+    encoder.createReadStream().pipe(writeStream);
+    encoder.start();
+    encoder.setRepeat(0);
+    encoder.setDelay(duration);
+    encoder.setQuality(10);
+    const fontFamily = pickFont();
+    const logo = show_logo ? await loadLogo() : null;
+    if (show_task && task) {
+        ctx.clearRect(0, 0, width, height);
+        // @ts-ignore - node-canvas types differ slightly from browser canvas
+        renderTaskFrame(ctx, width, height, task, fontFamily, font_size + 16, line_spacing, logo);
+        encoder.addFrame(ctx);
+    }
+    for (let index = 0; index < screenshots.length; index += 1) {
+        const screenshot = screenshots[index];
+        if (!screenshot || screenshot === PLACEHOLDER_4PX_SCREENSHOT) {
+            continue;
+        }
+        try {
+            const image = await loadScreenshot(screenshot);
+            ctx.clearRect(0, 0, width, height);
+            const goalText = show_goals &&
+                history.history[index]?.model_output?.current_state.next_goal
+                ? history.history[index].model_output.current_state.next_goal
+                : '';
+            // @ts-ignore - node-canvas types differ slightly from browser canvas
+            drawScreenshotFrame(ctx, width, height, image, index + 1, goalText, fontFamily, goal_font_size, logo);
+            encoder.addFrame(ctx);
+        }
+        catch (error) {
+            logger.warn(`Failed to process screenshot at step ${index + 1}: ${error.message}`);
+        }
+    }
+    encoder.finish();
+    await new Promise((resolve, reject) => {
+        writeStream.on('finish', resolve);
+        writeStream.on('error', reject);
+    });
+    logger.info(`Created GIF at ${output_path}`);
+};

package/dist/agent/index.d.ts

@@ -0,0 +1,8 @@
+export * from './views.js';
+export * from './message-manager/service.js';
+export * from './message-manager/views.js';
+export * from './message-manager/utils.js';
+export * from './prompts.js';
+export * from './cloud-events.js';
+export * from './gif.js';
+export * from './service.js';

package/dist/agent/index.js

@@ -0,0 +1,8 @@
+export * from './views.js';
+export * from './message-manager/service.js';
+export * from './message-manager/views.js';
+export * from './message-manager/utils.js';
+export * from './prompts.js';
+export * from './cloud-events.js';
+export * from './gif.js';
+export * from './service.js';

package/dist/agent/message-manager/service.d.ts

@@ -0,0 +1,30 @@
+import { SystemMessage, UserMessage, type Message } from '../../llm/messages.js';
+import { ActionResult, AgentOutput, AgentStepInfo } from '../views.js';
+import { BrowserStateSummary } from '../../browser/views.js';
+import { FileSystem } from '../../filesystem/file-system.js';
+import { MessageManagerState } from './views.js';
+export declare class MessageManager {
+    private readonly fileSystem;
+    private readonly state;
+    private readonly useThinking;
+    private readonly sensitiveData?;
+    private readonly maxHistoryItems;
+    private readonly visionDetailLevel;
+    private readonly includeToolCallExamples;
+    private task;
+    private systemPrompt;
+    private sensitiveDataDescription;
+    private lastInputMessages;
+    private includeAttributes;
+    constructor(task: string, systemMessage: SystemMessage, fileSystem: FileSystem, state?: MessageManagerState, useThinking?: boolean, includeAttributes?: string[] | null, sensitiveData?: Record<string, string | Record<string, string>> | undefined, maxHistoryItems?: number | null, visionDetailLevel?: 'auto' | 'low' | 'high', includeToolCallExamples?: boolean);
+    get agent_history_description(): string;
+    add_new_task(new_task: string): void;
+    private updateAgentHistoryDescription;
+    private getSensitiveDataDescription;
+    create_state_messages(browser_state_summary: BrowserStateSummary, model_output?: AgentOutput | null, result?: ActionResult[] | null, step_info?: AgentStepInfo | null, use_vision?: boolean, page_filtered_actions?: string | null, sensitive_data?: Record<string, string | Record<string, string>> | null, available_file_paths?: string[] | null): void;
+    get_messages(): Message[];
+    private setMessageWithType;
+    private addContextMessage;
+    _add_context_message(message: SystemMessage | UserMessage): void;
+    private filterSensitiveData;
+}

package/dist/agent/message-manager/service.js

@@ -0,0 +1,208 @@
+import { ContentPartTextParam, } from '../../llm/messages.js';
+import { AgentMessagePrompt } from '../prompts.js';
+import { MessageManagerState, HistoryItem } from './views.js';
+import { match_url_with_domain_pattern } from '../../utils.js';
+import { createLogger } from '../../logging-config.js';
+const logger = createLogger('browser_use.agent.message_manager');
+export class MessageManager {
+    fileSystem;
+    state;
+    useThinking;
+    sensitiveData;
+    maxHistoryItems;
+    visionDetailLevel;
+    includeToolCallExamples;
+    task;
+    systemPrompt;
+    sensitiveDataDescription = '';
+    lastInputMessages = [];
+    includeAttributes;
+    constructor(task, systemMessage, fileSystem, state = new MessageManagerState(), useThinking = true, includeAttributes = null, sensitiveData, maxHistoryItems = null, visionDetailLevel = 'auto', includeToolCallExamples = false) {
+        this.fileSystem = fileSystem;
+        this.state = state;
+        this.useThinking = useThinking;
+        this.sensitiveData = sensitiveData;
+        this.maxHistoryItems = maxHistoryItems;
+        this.visionDetailLevel = visionDetailLevel;
+        this.includeToolCallExamples = includeToolCallExamples;
+        this.task = task;
+        this.systemPrompt = systemMessage;
+        this.includeAttributes = includeAttributes ?? [];
+        if (!this.state.history.system_message) {
+            this.setMessageWithType(this.systemPrompt, 'system');
+        }
+    }
+    get agent_history_description() {
+        if (this.maxHistoryItems == null) {
+            return this.state.agent_history_items
+                .map((item) => item.to_string())
+                .join('\n');
+        }
+        const totalItems = this.state.agent_history_items.length;
+        if (totalItems <= this.maxHistoryItems) {
+            return this.state.agent_history_items
+                .map((item) => item.to_string())
+                .join('\n');
+        }
+        const omitted = totalItems - this.maxHistoryItems;
+        const keepRecent = this.maxHistoryItems - 1;
+        const parts = [];
+        parts.push(this.state.agent_history_items[0].to_string());
+        parts.push(`<sys>[... ${omitted} previous steps omitted...]</sys>`);
+        parts.push(...this.state.agent_history_items
+            .slice(-keepRecent)
+            .map((item) => item.to_string()));
+        return parts.join('\n');
+    }
+    add_new_task(new_task) {
+        this.task = new_task;
+        this.state.agent_history_items.push(new HistoryItem(null, null, null, null, null, null, `User updated <user_request> to: ${new_task}`));
+    }
+    updateAgentHistoryDescription(model_output, result, step_info) {
+        const results = result ?? [];
+        const stepNumber = step_info?.step_number ?? null;
+        this.state.read_state_description = '';
+        let actionText = '';
+        results.forEach((action, idx) => {
+            const suffix = `Action ${idx + 1}/${results.length}: `;
+            if (action.include_extracted_content_only_once &&
+                action.extracted_content) {
+                this.state.read_state_description += `${action.extracted_content}\n`;
+            }
+            if (action.long_term_memory) {
+                actionText += `${suffix}${action.long_term_memory}\n`;
+            }
+            else if (action.extracted_content &&
+                !action.include_extracted_content_only_once) {
+                actionText += `${suffix}${action.extracted_content}\n`;
+            }
+            if (action.error) {
+                const err = action.error.length > 200
+                    ? `${action.error.slice(0, 100)}......${action.error.slice(-100)}`
+                    : action.error;
+                actionText += `${suffix}${err}\n`;
+            }
+        });
+        const normalizedActionText = actionText ? actionText.trim() : null;
+        if (!model_output) {
+            if (stepNumber != null && stepNumber > 0) {
+                this.state.agent_history_items.push(new HistoryItem(stepNumber, null, null, null, null, 'Agent failed to output in the right format.', null));
+            }
+            return;
+        }
+        const brain = model_output.current_state;
+        this.state.agent_history_items.push(new HistoryItem(stepNumber, brain.evaluation_previous_goal, brain.memory, brain.next_goal, normalizedActionText, null, null));
+    }
+    getSensitiveDataDescription(currentUrl) {
+        const placeholders = new Set();
+        if (!this.sensitiveData) {
+            return '';
+        }
+        for (const [key, value] of Object.entries(this.sensitiveData)) {
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+                if (currentUrl &&
+                    match_url_with_domain_pattern(currentUrl, key, true)) {
+                    Object.keys(value).forEach((entry) => placeholders.add(entry));
+                }
+            }
+            else if (typeof value === 'string') {
+                placeholders.add(key);
+            }
+        }
+        if (!placeholders.size) {
+            return '';
+        }
+        return `Here are placeholders for sensitive data:\n${Array.from(placeholders).sort().join(', ')}\nTo use them, write <secret>the placeholder name</secret>`;
+    }
+    create_state_messages(browser_state_summary, model_output = null, result = null, step_info = null, use_vision = true, page_filtered_actions = null, sensitive_data = null, available_file_paths = null) {
+        this.state.history.context_messages = [];
+        this.updateAgentHistoryDescription(model_output, result, step_info);
+        if (sensitive_data) {
+            this.sensitiveDataDescription = this.getSensitiveDataDescription(browser_state_summary.url);
+        }
+        const screenshots = [];
+        if (browser_state_summary.screenshot) {
+            screenshots.push(browser_state_summary.screenshot);
+        }
+        const prompt = new AgentMessagePrompt({
+            browser_state_summary,
+            file_system: this.fileSystem,
+            agent_history_description: this.agent_history_description,
+            read_state_description: this.state.read_state_description,
+            task: this.task,
+            include_attributes: this.includeAttributes,
+            step_info,
+            page_filtered_actions,
+            sensitive_data: this.sensitiveDataDescription,
+            available_file_paths,
+            screenshots,
+            vision_detail_level: this.visionDetailLevel,
+        });
+        const message = prompt.get_user_message(use_vision);
+        this.setMessageWithType(message, 'state');
+    }
+    get_messages() {
+        logger.debug('');
+        this.lastInputMessages = this.state.history.get_messages();
+        return this.lastInputMessages;
+    }
+    setMessageWithType(message, messageType) {
+        const filtered = this.sensitiveData
+            ? this.filterSensitiveData(message)
+            : message;
+        if (messageType === 'system') {
+            this.state.history.system_message = filtered;
+        }
+        else {
+            this.state.history.state_message = filtered;
+        }
+    }
+    addContextMessage(message) {
+        const filtered = this.sensitiveData
+            ? this.filterSensitiveData(message)
+            : message;
+        this.state.history.context_messages.push(filtered);
+    }
+    _add_context_message(message) {
+        this.addContextMessage(message);
+    }
+    filterSensitiveData(message) {
+        if (!this.sensitiveData) {
+            return message;
+        }
+        const replaceSensitive = (value) => {
+            const placeholders = {};
+            for (const [keyOrDomain, content] of Object.entries(this.sensitiveData)) {
+                if (content && typeof content === 'object' && !Array.isArray(content)) {
+                    for (const [k, v] of Object.entries(content)) {
+                        if (v)
+                            placeholders[k] = v;
+                    }
+                }
+                else if (typeof content === 'string') {
+                    placeholders[keyOrDomain] = content;
+                }
+            }
+            if (!Object.keys(placeholders).length) {
+                return value;
+            }
+            let updated = value;
+            for (const [key, val] of Object.entries(placeholders)) {
+                updated = updated.replaceAll(val, `<secret>${key}</secret>`);
+            }
+            return updated;
+        };
+        if (typeof message.content === 'string') {
+            message.content = replaceSensitive(message.content);
+        }
+        else if (Array.isArray(message.content)) {
+            message.content = message.content.map((part) => {
+                if (part instanceof ContentPartTextParam) {
+                    part.text = replaceSensitive(part.text);
+                }
+                return part;
+            });
+        }
+        return message;
+    }
+}

package/dist/agent/message-manager/utils.d.ts

@@ -0,0 +1,2 @@
+import { Message } from '../../llm/messages.js';
+export declare const saveConversation: (inputMessages: Message[], response: unknown, target: string, encoding?: BufferEncoding) => Promise<void>;

package/dist/agent/message-manager/utils.js

@@ -0,0 +1,41 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const serializeResponse = (response) => {
+    if (!response) {
+        return '';
+    }
+    if (typeof response.model_dump_json === 'function') {
+        try {
+            const raw = response.model_dump_json({ exclude_unset: true });
+            return JSON.stringify(JSON.parse(raw), null, 2);
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    try {
+        return JSON.stringify(response, null, 2);
+    }
+    catch {
+        return String(response);
+    }
+};
+const formatConversation = (messages, response) => {
+    const lines = [];
+    messages.forEach((message) => {
+        lines.push(` ${message.role} `);
+        lines.push(typeof message.text === 'function'
+            ? message.text()
+            : (message.text ?? ''));
+        lines.push('');
+    });
+    lines.push(' RESPONSE');
+    lines.push(serializeResponse(response));
+    return lines.join('\n');
+};
+export const saveConversation = async (inputMessages, response, target, encoding = 'utf-8') => {
+    const targetPath = path.resolve(target);
+    await fs.promises.mkdir(path.dirname(targetPath), { recursive: true });
+    const payload = formatConversation(inputMessages, response);
+    await fs.promises.writeFile(targetPath, payload, { encoding });
+};

package/dist/agent/message-manager/views.d.ts

@@ -0,0 +1,26 @@
+import type { Message } from '../../llm/messages.js';
+export declare class HistoryItem {
+    step_number: number | null;
+    evaluation_previous_goal: string | null;
+    memory: string | null;
+    next_goal: string | null;
+    action_results: string | null;
+    error: string | null;
+    system_message: string | null;
+    constructor(step_number?: number | null, evaluation_previous_goal?: string | null, memory?: string | null, next_goal?: string | null, action_results?: string | null, error?: string | null, system_message?: string | null);
+    to_string(): string;
+}
+export declare class MessageHistory {
+    system_message: Message | null;
+    state_message: Message | null;
+    context_messages: Message[];
+    get_messages(): Message[];
+}
+export declare class MessageManagerState {
+    history: MessageHistory;
+    tool_id: number;
+    agent_history_items: HistoryItem[];
+    read_state_description: string;
+    get historyMessages(): Message[];
+    get_messages(): Message[];
+}

package/dist/agent/message-manager/views.js

@@ -0,0 +1,73 @@
+export class HistoryItem {
+    step_number;
+    evaluation_previous_goal;
+    memory;
+    next_goal;
+    action_results;
+    error;
+    system_message;
+    constructor(step_number = null, evaluation_previous_goal = null, memory = null, next_goal = null, action_results = null, error = null, system_message = null) {
+        this.step_number = step_number;
+        this.evaluation_previous_goal = evaluation_previous_goal;
+        this.memory = memory;
+        this.next_goal = next_goal;
+        this.action_results = action_results;
+        this.error = error;
+        this.system_message = system_message;
+        if (this.error && this.system_message) {
+            throw new Error('Cannot have both error and system_message at the same time');
+        }
+    }
+    to_string() {
+        const stepStr = this.step_number != null ? `step_${this.step_number}` : 'step_unknown';
+        if (this.error) {
+            return `<${stepStr}>\n${this.error}\n</${stepStr}>`;
+        }
+        if (this.system_message) {
+            return `<sys>\n${this.system_message}\n</sys>`;
+        }
+        const parts = [];
+        if (this.evaluation_previous_goal) {
+            parts.push(`Evaluation of Previous Step: ${this.evaluation_previous_goal}`);
+        }
+        if (this.memory) {
+            parts.push(`Memory: ${this.memory}`);
+        }
+        if (this.next_goal) {
+            parts.push(`Next Goal: ${this.next_goal}`);
+        }
+        if (this.action_results) {
+            parts.push(this.action_results);
+        }
+        const content = parts.join('\n');
+        return `<${stepStr}>\n${content}\n</${stepStr}>`;
+    }
+}
+export class MessageHistory {
+    system_message = null;
+    state_message = null;
+    context_messages = [];
+    get_messages() {
+        const messages = [];
+        if (this.system_message)
+            messages.push(this.system_message);
+        if (this.state_message)
+            messages.push(this.state_message);
+        messages.push(...this.context_messages);
+        return messages;
+    }
+}
+export class MessageManagerState {
+    history = new MessageHistory();
+    tool_id = 1;
+    agent_history_items = [
+        new HistoryItem(0, null, null, null, null, null, 'Agent initialized'),
+    ];
+    read_state_description = '';
+    get historyMessages() {
+        return this.history.get_messages();
+    }
+    get_messages() {
+        return this.history.get_messages();
+    }
+}

package/dist/agent/prompts.d.ts

@@ -0,0 +1,52 @@
+import { SystemMessage, UserMessage } from '../llm/messages.js';
+import type { AgentStepInfo } from './views.js';
+import type { BrowserStateSummary } from '../browser/views.js';
+import type { FileSystem } from '../filesystem/file-system.js';
+export declare class SystemPrompt {
+    private readonly actionDescription;
+    private readonly maxActionsPerStep;
+    private readonly overrideSystemMessage;
+    private readonly extendSystemMessage;
+    private readonly useThinking;
+    private readonly flashMode;
+    private promptTemplate;
+    private systemMessage;
+    constructor(actionDescription: string, maxActionsPerStep?: number, overrideSystemMessage?: string | null, extendSystemMessage?: string | null, useThinking?: boolean, flashMode?: boolean);
+    private loadPromptTemplate;
+    get_system_message(): SystemMessage;
+}
+interface AgentMessagePromptInit {
+    browser_state_summary: BrowserStateSummary;
+    file_system: FileSystem;
+    agent_history_description?: string | null;
+    read_state_description?: string | null;
+    task?: string | null;
+    include_attributes?: string[] | null;
+    step_info?: AgentStepInfo | null;
+    page_filtered_actions?: string | null;
+    max_clickable_elements_length?: number;
+    sensitive_data?: string | null;
+    available_file_paths?: string[] | null;
+    screenshots?: string[] | null;
+    vision_detail_level?: 'auto' | 'low' | 'high';
+}
+export declare class AgentMessagePrompt {
+    private readonly browserState;
+    private readonly fileSystem;
+    private readonly agentHistoryDescription;
+    private readonly readStateDescription;
+    private readonly task;
+    private readonly includeAttributes?;
+    private readonly stepInfo?;
+    private readonly pageFilteredActions;
+    private readonly maxClickableElementsLength;
+    private readonly sensitiveData;
+    private readonly availableFilePaths?;
+    private readonly screenshots;
+    private readonly visionDetailLevel;
+    constructor(init: AgentMessagePromptInit);
+    private browserStateDescription;
+    private agentStateDescription;
+    get_user_message(use_vision?: boolean): UserMessage;
+}
+export {};