@blackbox_ai/blackbox-cli-core 0.0.4 → 0.0.6

package/dist/src/tools/browser_use.js

@@ -0,0 +1,870 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { chromium } from 'playwright';
+import { ToolNames } from './tool-names.js';
+import { ToolErrorType } from './tool-error.js';
+import { BaseDeclarativeTool, BaseToolInvocation, Kind, } from './tools.js';
+const screenshotPrompt = `Here are the action result, console logs and screenshot after the action execution.
+Carefully review and decide the next steps to complete the task successfully.`;
+/**
+ * Singleton browser session manager
+ */
+export class ServerBrowserSession {
+    browser;
+    page;
+    currentMousePosition;
+    static instance;
+    constructor() { }
+    static getInstance() {
+        if (!ServerBrowserSession.instance) {
+            ServerBrowserSession.instance = new ServerBrowserSession();
+        }
+        return ServerBrowserSession.instance;
+    }
+    async launchBrowser() {
+        console.log('Launching browser...');
+        if (this.browser) {
+            await this.closeBrowser();
+        }
+        try {
+            this.browser = await chromium.launch({
+                args: [
+                    '--user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36',
+                    '--no-sandbox',
+                    '--disable-setuid-sandbox',
+                    '--disable-dev-shm-usage',
+                    '--disable-gpu',
+                    '--disable-web-security',
+                    '--disable-extensions',
+                    '--force-device-scale-factor=1',
+                    '--disable-background-timer-throttling',
+                    '--disable-backgrounding-occluded-windows',
+                    '--disable-renderer-backgrounding',
+                ],
+                headless: true,
+            });
+            const context = await this.browser.newContext({
+                viewport: { width: 900, height: 600 },
+                deviceScaleFactor: 1,
+                screen: { width: 900, height: 600 },
+                ignoreHTTPSErrors: true,
+                bypassCSP: true,
+            });
+            this.page = await context.newPage();
+            // Set a default background to ensure screenshots work
+            await this.page.addStyleTag({
+                content: `
+          html, body {
+            background-color: white !important;
+            min-height: 100vh;
+          }
+        `,
+            });
+            console.log('Browser launched successfully with 900x600 viewport');
+            return {
+                execution_success: true,
+                logs: 'Browser session started successfully with 900x600 viewport',
+                execution_logs: 'Browser launched and ready for interaction at 900x600 resolution',
+            };
+        }
+        catch (error) {
+            const errorMessage = `Failed to launch browser: ${error instanceof Error ? error.message : String(error)}`;
+            console.error(`[Error] Exception during Starting browser - ${errorMessage}`);
+            return {
+                execution_success: false,
+                logs: errorMessage,
+                execution_logs: errorMessage,
+            };
+        }
+    }
+    async closeBrowser() {
+        if (this.browser || this.page) {
+            console.log('Closing browser...');
+            try {
+                await this.browser?.close();
+                this.browser = undefined;
+                this.page = undefined;
+                this.currentMousePosition = undefined;
+                return {
+                    execution_success: true,
+                    logs: 'Browser session closed successfully',
+                    execution_logs: 'Browser closed successfully',
+                };
+            }
+            catch (error) {
+                const errorMessage = `Error closing browser: ${error instanceof Error ? error.message : String(error)}`;
+                console.warn(errorMessage);
+                return {
+                    execution_success: false,
+                    logs: errorMessage,
+                    execution_logs: errorMessage,
+                };
+            }
+        }
+        return {
+            execution_success: true,
+            logs: 'Browser was already closed',
+            execution_logs: 'No browser to close',
+        };
+    }
+    async waitTillHTMLStable(timeout = 5000) {
+        if (!this.page)
+            return;
+        const checkDurationMs = 500;
+        const maxChecks = timeout / checkDurationMs;
+        let lastHTMLSize = 0;
+        let checkCounts = 1;
+        let countStableSizeIterations = 0;
+        const minStableSizeIterations = 3;
+        while (checkCounts <= maxChecks) {
+            try {
+                const html = await this.page.content();
+                const currentHTMLSize = html.length;
+                console.log(`last: ${lastHTMLSize} <> curr: ${currentHTMLSize}`);
+                if (lastHTMLSize !== 0 && currentHTMLSize === lastHTMLSize) {
+                    countStableSizeIterations++;
+                }
+                else {
+                    countStableSizeIterations = 0;
+                }
+                if (countStableSizeIterations >= minStableSizeIterations) {
+                    console.log('Page rendered fully...');
+                    break;
+                }
+                lastHTMLSize = currentHTMLSize;
+                await new Promise((resolve) => setTimeout(resolve, checkDurationMs));
+                checkCounts++;
+            }
+            catch (error) {
+                console.warn('Error checking HTML stability:', error);
+                break;
+            }
+        }
+    }
+    async doAction(action) {
+        let executionSuccess = true;
+        let screenshot;
+        if (!this.page) {
+            executionSuccess = false;
+            throw new Error('Browser is not launched. This may occur if the browser was automatically closed.');
+        }
+        const logs = [];
+        let executionLog = '';
+        let lastLogTs = Date.now();
+        const consoleListener = (msg) => {
+            try {
+                if (msg.type() === 'log') {
+                    logs.push(msg.text());
+                }
+                else {
+                    logs.push(`[${msg.type()}] ${msg.text()}`);
+                }
+                lastLogTs = Date.now();
+            }
+            catch (error) {
+                logs.push(`[Console Error] ${error instanceof Error ? error.message : String(error)}`);
+            }
+        };
+        this.page.on('console', consoleListener);
+        try {
+            const result = await action();
+            executionLog += `\n ${result}`;
+        }
+        catch (err) {
+            executionLog += `\n [Error] ${err instanceof Error ? err.message : String(err)}`;
+            executionSuccess = false;
+        }
+        // Wait for console inactivity
+        try {
+            await this.waitForConsoleInactivity(lastLogTs);
+        }
+        catch (error) {
+            // Timeout is expected
+        }
+        try {
+            // Ensure page is ready for screenshot
+            await this.page.waitForLoadState('domcontentloaded', { timeout: 5000 });
+            // Take high-quality screenshot with exact 900x600 dimensions to match viewport
+            const screenshotBytes = await this.page.screenshot({
+                type: 'png',
+                fullPage: false, // Only capture viewport
+                clip: { x: 0, y: 0, width: 900, height: 600 }, // Exact viewport dimensions
+                omitBackground: false,
+            });
+            if (screenshotBytes && screenshotBytes.length > 0) {
+                const screenshotBase64 = screenshotBytes.toString('base64');
+                screenshot = `data:image/png;base64,${screenshotBase64}`;
+                // Log screenshot success with dimensions
+                console.log(`Screenshot captured: 900x600px, ${screenshotBase64.length} chars, data URI length: ${screenshot.length}`);
+                executionLog += `\nScreenshot captured at 900x600 resolution (1:1 scale with viewport)`;
+            }
+            else {
+                console.error('Screenshot capture returned empty buffer');
+                executionLog += `\n[Error] Screenshot capture returned empty buffer`;
+            }
+        }
+        catch (error) {
+            console.error('Screenshot capture failed:', error);
+            executionLog += `\n[Error] Error taking screenshot of the current state of page! ${error instanceof Error ? error.message : String(error)}`;
+            // Try alternative screenshot method as fallback
+            try {
+                console.log('Attempting fallback screenshot method...');
+                const fallbackBytes = await this.page.screenshot({
+                    type: 'png',
+                    fullPage: false,
+                });
+                if (fallbackBytes && fallbackBytes.length > 0) {
+                    const fallbackBase64 = fallbackBytes.toString('base64');
+                    screenshot = `data:image/png;base64,${fallbackBase64}`;
+                    console.log(`Fallback screenshot captured: ${fallbackBase64.length} chars`);
+                    executionLog += `\nFallback screenshot captured successfully`;
+                }
+            }
+            catch (fallbackError) {
+                console.error('Fallback screenshot also failed:', fallbackError);
+                executionLog += `\n[Error] Fallback screenshot also failed: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`;
+            }
+        }
+        try {
+            this.page.off('console', consoleListener);
+        }
+        catch (error) {
+            console.log(`Error removing console listener: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (executionSuccess) {
+            executionLog += '\n Action executed Successfully!';
+        }
+        return {
+            execution_success: executionSuccess,
+            screenshot,
+            console_logs: logs.join('\n'),
+            execution_logs: executionLog,
+            currentUrl: this.page.url(),
+            currentMousePosition: this.currentMousePosition,
+            // Also provide the old format for backward compatibility
+            logs: logs.join('\n'),
+        };
+    }
+    async waitForConsoleInactivity(lastLogTs, timeout = 3000) {
+        const startTime = Date.now();
+        while (Date.now() - lastLogTs < 500 &&
+            Date.now() - startTime < timeout) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    async navigateToUrl(url) {
+        if (!this.page || !this.browser) {
+            const launchResult = await this.launchBrowser();
+            if (!launchResult.execution_success) {
+                return launchResult;
+            }
+        }
+        return this.doAction(async () => {
+            if (!this.page)
+                throw new Error('Page not available');
+            let executionLog = '';
+            console.log(`Navigating to URL: ${url}`);
+            try {
+                const response = await this.page.goto(url, {
+                    timeout: 30000,
+                    waitUntil: 'domcontentloaded',
+                });
+                if (!response) {
+                    executionLog += `\nNavigation failed or no response received for URL: ${url}`;
+                    throw new Error(`Navigation failed or no response received for URL: ${url}`);
+                }
+                const status = response.status();
+                executionLog += `\nNavigated to URL: ${url} (Status: ${status})`;
+                if (status >= 400) {
+                    executionLog += `\nWarning: HTTP status ${status} - page may have errors`;
+                }
+                // Wait for network to be idle and page to stabilize
+                await this.page.waitForLoadState('networkidle', { timeout: 10000 });
+                await this.waitTillHTMLStable();
+                console.log(`Page navigation completed successfully for: ${url}`);
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.error(`Navigation error for ${url}:`, errorMsg);
+                executionLog += `\nNavigation error: ${errorMsg}`;
+                throw error;
+            }
+            return executionLog;
+        });
+    }
+    async click(coordinate) {
+        const [x, y] = coordinate.split(',').map(Number);
+        // Validate coordinates are within viewport bounds
+        if (isNaN(x) || isNaN(y)) {
+            throw new Error(`Invalid coordinates: ${coordinate}. Must be in "x,y" format with valid numbers.`);
+        }
+        if (x < 0 || x > 900 || y < 0 || y > 600) {
+            throw new Error(`Coordinates (${x}, ${y}) are outside viewport bounds (0-900, 0-600).`);
+        }
+        return this.doAction(async () => {
+            if (!this.page)
+                throw new Error('Page not available');
+            let hasNetworkActivity = false;
+            let executionLog = '';
+            console.log(`Clicking at coordinates: (${x}, ${y}) within 900x600 viewport`);
+            const requestListener = () => {
+                hasNetworkActivity = true;
+            };
+            try {
+                this.page.on('request', requestListener);
+                // Move mouse to position first, then click
+                await this.page.mouse.move(x, y);
+                await this.page.mouse.click(x, y);
+                this.currentMousePosition = coordinate;
+                executionLog += `\nClick Action Performed at exact coordinates (${x}, ${y})`;
+                executionLog += `\nViewport: 900x600 pixels, Click position: ${((x / 900) * 100).toFixed(1)}% from left, ${((y / 600) * 100).toFixed(1)}% from top`;
+                // Wait a moment for potential page changes
+                await new Promise((resolve) => setTimeout(resolve, 500));
+                if (hasNetworkActivity) {
+                    try {
+                        console.log('Network activity detected, waiting for page to stabilize...');
+                        await this.page.waitForLoadState('networkidle', { timeout: 7000 });
+                        await this.waitTillHTMLStable();
+                        executionLog += '\nPage updated after click';
+                    }
+                    catch (error) {
+                        // Navigation timeout is common and not necessarily an error
+                        console.log('Navigation wait timeout (expected for non-navigating clicks)');
+                        executionLog += '\nClick completed (no page navigation)';
+                    }
+                }
+                else {
+                    executionLog += '\nClick completed (no network activity)';
+                }
+                console.log('Click action completed successfully');
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.error('Click action failed:', errorMsg);
+                executionLog += `\nClick error: ${errorMsg}`;
+                throw error;
+            }
+            finally {
+                this.page.off('request', requestListener);
+            }
+            return executionLog;
+        });
+    }
+    async type(text) {
+        return this.doAction(async () => {
+            if (!this.page)
+                throw new Error('Page not available');
+            await this.page.keyboard.type(text);
+            return 'Type action performed!';
+        });
+    }
+    async scrollDown() {
+        return this.doAction(async () => {
+            if (!this.page)
+                throw new Error('Page not available');
+            await this.page.evaluate("window.scrollBy({top: 400, behavior: 'auto'})");
+            await new Promise((resolve) => setTimeout(resolve, 300));
+            return 'Scroll down action performed!';
+        });
+    }
+    async scrollUp() {
+        return this.doAction(async () => {
+            if (!this.page)
+                throw new Error('Page not available');
+            await this.page.evaluate("window.scrollBy({top: -600, behavior: 'auto'})");
+            await new Promise((resolve) => setTimeout(resolve, 300));
+            return 'Scroll up action performed!';
+        });
+    }
+}
+class BrowserLaunchToolInvocation extends BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    getDescription() {
+        return 'Launching browser with 900x600 viewport';
+    }
+    async execute() {
+        const session = ServerBrowserSession.getInstance();
+        const result = await session.launchBrowser();
+        console.log('[BrowserLaunchTool] Browser launch completed', {
+            success: result.execution_success,
+        });
+        if (!result.execution_success) {
+            return {
+                llmContent: result.execution_logs || 'Failed to launch browser',
+                returnDisplay: result.logs || 'Failed to launch browser',
+                error: {
+                    message: result.logs || 'Failed to launch browser',
+                    type: ToolErrorType.BROWSER_LAUNCH_ERROR,
+                },
+            };
+        }
+        return {
+            llmContent: result.execution_logs || 'Browser launched successfully',
+            returnDisplay: result.logs || 'Browser launched successfully',
+        };
+    }
+}
+export class BrowserLaunchTool extends BaseDeclarativeTool {
+    config;
+    static Name = ToolNames.BROWSER_LAUNCH;
+    // @ts-expect-error - Required by base class pattern
+    constructor(config) {
+        super(BrowserLaunchTool.Name, 'BrowserLaunch', 'Launches a Puppeteer-controlled browser instance with a 900x600 viewport. This must always be the first browser action before any other browser operations.', Kind.Execute, {
+            type: 'object',
+            properties: {},
+            required: [],
+        }, false);
+        this.config = config;
+    }
+    createInvocation(params) {
+        return new BrowserLaunchToolInvocation(params);
+    }
+}
+class BrowserNavigateToolInvocation extends BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    getDescription() {
+        return `Navigating to ${this.params.url}`;
+    }
+    async execute() {
+        const session = ServerBrowserSession.getInstance();
+        const result = await session.navigateToUrl(this.params.url);
+        console.log('[BrowserNavigateTool] Navigation completed', {
+            url: this.params.url,
+            success: result.execution_success,
+            currentUrl: result.currentUrl,
+        });
+        const llmContent = [
+            `${screenshotPrompt}`,
+            `URL: ${this.params.url}`,
+            `Status: ${result.execution_success ? 'Success' : 'Failed'}`,
+            `Current URL: ${result.currentUrl || 'N/A'}`,
+            `Console Logs: ${result.console_logs || '(none)'}`,
+            `Execution Details: ${result.execution_logs || ''}`,
+        ].join('\n');
+        if (!result.execution_success) {
+            return {
+                llmContent,
+                returnDisplay: result.logs || 'Navigation failed',
+                error: {
+                    message: result.logs || 'Navigation failed',
+                    type: ToolErrorType.BROWSER_NAVIGATE_ERROR,
+                },
+            };
+        }
+        // Include screenshot in response
+        const llmParts = [llmContent];
+        if (result.screenshot) {
+            llmParts.push({
+                inlineData: {
+                    mimeType: 'image/png',
+                    data: result.screenshot.split(',')[1], // Remove data:image/png;base64, prefix
+                },
+            });
+        }
+        return {
+            llmContent: llmParts,
+            returnDisplay: result.logs || 'Navigation successful',
+        };
+    }
+}
+export class BrowserNavigateTool extends BaseDeclarativeTool {
+    config;
+    static Name = ToolNames.BROWSER_NAVIGATE;
+    // @ts-expect-error - Required by base class pattern
+    constructor(config) {
+        super(BrowserNavigateTool.Name, 'BrowserNavigate', 'Navigates the browser to a specified URL. The browser must be launched first. Returns a screenshot of the page after navigation.', Kind.Execute, {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'The URL to navigate to (e.g., http://localhost:3000, https://example.com, file:///path/to/file.html)',
+                },
+            },
+            required: ['url'],
+        }, false);
+        this.config = config;
+    }
+    validateToolParamValues(params) {
+        if (!params.url || params.url.trim() === '') {
+            return 'URL parameter must be non-empty';
+        }
+        // Basic URL validation
+        try {
+            new URL(params.url);
+        }
+        catch (error) {
+            // Check if it's a file path
+            if (!params.url.startsWith('file://') && !params.url.startsWith('http')) {
+                return `Invalid URL format: ${params.url}. Must be a valid URL (http://, https://, or file://)`;
+            }
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new BrowserNavigateToolInvocation(params);
+    }
+}
+class BrowserClickToolInvocation extends BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    getDescription() {
+        return `Clicking at coordinates ${this.params.coordinate}`;
+    }
+    async execute() {
+        const session = ServerBrowserSession.getInstance();
+        const result = await session.click(this.params.coordinate);
+        const [x, y] = this.params.coordinate.split(',').map(Number);
+        console.log('[BrowserClickTool] Click completed', {
+            coordinate: this.params.coordinate,
+            success: result.execution_success,
+            currentUrl: result.currentUrl,
+        });
+        const llmContent = [
+            `${screenshotPrompt}`,
+            `Coordinate: ${this.params.coordinate} (${x}, ${y})`,
+            `Status: ${result.execution_success ? 'Success' : 'Failed'}`,
+            `Current URL: ${result.currentUrl || 'N/A'}`,
+            `Mouse Position: ${result.currentMousePosition || 'N/A'}`,
+            `Console Logs: ${result.console_logs || '(none)'}`,
+            `Execution Details: ${result.execution_logs || ''}`,
+        ].join('\n');
+        if (!result.execution_success) {
+            return {
+                llmContent,
+                returnDisplay: result.logs || 'Click failed',
+                error: {
+                    message: result.logs || 'Click failed',
+                    type: ToolErrorType.BROWSER_CLICK_ERROR,
+                },
+            };
+        }
+        // Include screenshot in response
+        const llmParts = [llmContent];
+        if (result.screenshot) {
+            llmParts.push({
+                inlineData: {
+                    mimeType: 'image/png',
+                    data: result.screenshot.split(',')[1],
+                },
+            });
+        }
+        return {
+            llmContent: llmParts,
+            returnDisplay: result.logs || 'Click successful',
+        };
+    }
+}
+export class BrowserClickTool extends BaseDeclarativeTool {
+    config;
+    static Name = ToolNames.BROWSER_CLICK;
+    // @ts-expect-error - Required by base class pattern
+    constructor(config) {
+        super(BrowserClickTool.Name, 'BrowserClick', 'Clicks at a specific x,y coordinate in the browser. The browser window has a resolution of 900x600 pixels. Always click in the center of an element based on coordinates derived from a screenshot. Returns a screenshot after the click.', Kind.Execute, {
+            type: 'object',
+            properties: {
+                coordinate: {
+                    type: 'string',
+                    description: 'The X and Y coordinates for the click action in "x,y" format (e.g., "450,300"). Coordinates must be within 0-900 for x and 0-600 for y.',
+                },
+            },
+            required: ['coordinate'],
+        }, false);
+        this.config = config;
+    }
+    validateToolParamValues(params) {
+        if (!params.coordinate || params.coordinate.trim() === '') {
+            return 'Coordinate parameter must be non-empty';
+        }
+        const parts = params.coordinate.split(',');
+        if (parts.length !== 2) {
+            return 'Coordinate must be in "x,y" format';
+        }
+        const [x, y] = parts.map(Number);
+        if (isNaN(x) || isNaN(y)) {
+            return 'Coordinate values must be valid numbers';
+        }
+        if (x < 0 || x > 900 || y < 0 || y > 600) {
+            return `Coordinates (${x}, ${y}) are outside viewport bounds (0-900, 0-600)`;
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new BrowserClickToolInvocation(params);
+    }
+}
+class BrowserTypeToolInvocation extends BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    getDescription() {
+        const preview = this.params.text.length > 50
+            ? this.params.text.substring(0, 50) + '...'
+            : this.params.text;
+        return `Typing text: "${preview}"`;
+    }
+    async execute() {
+        const session = ServerBrowserSession.getInstance();
+        const result = await session.type(this.params.text);
+        console.log('[BrowserTypeTool] Type completed', {
+            textLength: this.params.text.length,
+            success: result.execution_success,
+            currentUrl: result.currentUrl,
+        });
+        const llmContent = [
+            `${screenshotPrompt}`,
+            `Text: ${this.params.text}`,
+            `Status: ${result.execution_success ? 'Success' : 'Failed'}`,
+            `Current URL: ${result.currentUrl || 'N/A'}`,
+            `Console Logs: ${result.console_logs || '(none)'}`,
+            `Execution Details: ${result.execution_logs || ''}`,
+        ].join('\n');
+        if (!result.execution_success) {
+            return {
+                llmContent,
+                returnDisplay: result.logs || 'Type action failed',
+                error: {
+                    message: result.logs || 'Type action failed',
+                    type: ToolErrorType.BROWSER_TYPE_ERROR,
+                },
+            };
+        }
+        // Include screenshot in response
+        const llmParts = [llmContent];
+        if (result.screenshot) {
+            llmParts.push({
+                inlineData: {
+                    mimeType: 'image/png',
+                    data: result.screenshot.split(',')[1],
+                },
+            });
+        }
+        return {
+            llmContent: llmParts,
+            returnDisplay: result.logs || 'Text typed successfully',
+        };
+    }
+}
+export class BrowserTypeTool extends BaseDeclarativeTool {
+    config;
+    static Name = ToolNames.BROWSER_TYPE;
+    // @ts-expect-error - Required by base class pattern
+    constructor(config) {
+        super(BrowserTypeTool.Name, 'BrowserType', 'Types a string of text on the keyboard. Use this after clicking on a text field to input text. Returns a screenshot after typing.', Kind.Execute, {
+            type: 'object',
+            properties: {
+                text: {
+                    type: 'string',
+                    description: 'The text string to type',
+                },
+            },
+            required: ['text'],
+        }, false);
+        this.config = config;
+    }
+    validateToolParamValues(params) {
+        if (params.text === undefined || params.text === null) {
+            return 'Text parameter is required';
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new BrowserTypeToolInvocation(params);
+    }
+}
+class BrowserScrollDownToolInvocation extends BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    getDescription() {
+        return 'Scrolling down the page';
+    }
+    async execute() {
+        const session = ServerBrowserSession.getInstance();
+        const result = await session.scrollDown();
+        console.log('[BrowserScrollDownTool] Scroll down completed', {
+            success: result.execution_success,
+            currentUrl: result.currentUrl,
+        });
+        const llmContent = [
+            `${screenshotPrompt}`,
+            `Action: Scroll Down`,
+            `Status: ${result.execution_success ? 'Success' : 'Failed'}`,
+            `Current URL: ${result.currentUrl || 'N/A'}`,
+            `Console Logs: ${result.console_logs || '(none)'}`,
+            `Execution Details: ${result.execution_logs || ''}`,
+        ].join('\n');
+        if (!result.execution_success) {
+            return {
+                llmContent,
+                returnDisplay: result.logs || 'Scroll down failed',
+                error: {
+                    message: result.logs || 'Scroll down failed',
+                    type: ToolErrorType.BROWSER_SCROLL_ERROR,
+                },
+            };
+        }
+        // Include screenshot in response
+        const llmParts = [llmContent];
+        if (result.screenshot) {
+            llmParts.push({
+                inlineData: {
+                    mimeType: 'image/png',
+                    data: result.screenshot.split(',')[1],
+                },
+            });
+        }
+        return {
+            llmContent: llmParts,
+            returnDisplay: result.logs || 'Scroll down successful',
+        };
+    }
+}
+export class BrowserScrollDownTool extends BaseDeclarativeTool {
+    config;
+    static Name = ToolNames.BROWSER_SCROLL_DOWN;
+    // @ts-expect-error - Required by base class pattern
+    constructor(config) {
+        super(BrowserScrollDownTool.Name, 'BrowserScrollDown', 'Scrolls down the page by one page height (400 pixels). Returns a screenshot after scrolling.', Kind.Execute, {
+            type: 'object',
+            properties: {
+                amount: {
+                    type: 'number',
+                    description: 'The amount to scroll down',
+                },
+            },
+            required: ['amount'],
+        }, false);
+        this.config = config;
+    }
+    createInvocation(params) {
+        return new BrowserScrollDownToolInvocation(params);
+    }
+}
+class BrowserScrollUpToolInvocation extends BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    getDescription() {
+        return 'Scrolling up the page';
+    }
+    async execute() {
+        const session = ServerBrowserSession.getInstance();
+        const result = await session.scrollUp();
+        console.log('[BrowserScrollUpTool] Scroll up completed', {
+            success: result.execution_success,
+            currentUrl: result.currentUrl,
+        });
+        const llmContent = [
+            `${screenshotPrompt}`,
+            `Action: Scroll Up`,
+            `Status: ${result.execution_success ? 'Success' : 'Failed'}`,
+            `Current URL: ${result.currentUrl || 'N/A'}`,
+            `Console Logs: ${result.console_logs || '(none)'}`,
+            `Execution Details: ${result.execution_logs || ''}`,
+        ].join('\n');
+        if (!result.execution_success) {
+            return {
+                llmContent,
+                returnDisplay: result.logs || 'Scroll up failed',
+                error: {
+                    message: result.logs || 'Scroll up failed',
+                    type: ToolErrorType.BROWSER_SCROLL_ERROR,
+                },
+            };
+        }
+        // Include screenshot in response
+        const llmParts = [llmContent];
+        if (result.screenshot) {
+            llmParts.push({
+                inlineData: {
+                    mimeType: 'image/png',
+                    data: result.screenshot.split(',')[1],
+                },
+            });
+        }
+        return {
+            llmContent: llmParts,
+            returnDisplay: result.logs || 'Scroll up successful',
+        };
+    }
+}
+export class BrowserScrollUpTool extends BaseDeclarativeTool {
+    config;
+    static Name = ToolNames.BROWSER_SCROLL_UP;
+    // @ts-expect-error - Required by base class pattern
+    constructor(config) {
+        super(BrowserScrollUpTool.Name, 'BrowserScrollUp', 'Scrolls up the page by one page height (600 pixels). Returns a screenshot after scrolling.', Kind.Execute, {
+            type: 'object',
+            properties: {
+                amount: {
+                    type: 'number',
+                    description: 'The amount to scroll up',
+                },
+            },
+            required: ['amount'],
+        }, false);
+        this.config = config;
+    }
+    createInvocation(params) {
+        return new BrowserScrollUpToolInvocation(params);
+    }
+}
+class BrowserCloseToolInvocation extends BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    getDescription() {
+        return 'Closing browser';
+    }
+    async execute() {
+        const session = ServerBrowserSession.getInstance();
+        const result = await session.closeBrowser();
+        console.log('[BrowserCloseTool] Browser close completed', {
+            success: result.execution_success,
+        });
+        if (!result.execution_success) {
+            return {
+                llmContent: result.execution_logs || 'Failed to close browser',
+                returnDisplay: result.logs || 'Failed to close browser',
+                error: {
+                    message: result.logs || 'Failed to close browser',
+                    type: ToolErrorType.BROWSER_CLOSE_ERROR,
+                },
+            };
+        }
+        return {
+            llmContent: result.execution_logs || 'Browser closed successfully',
+            returnDisplay: result.logs || 'Browser closed successfully',
+        };
+    }
+}
+export class BrowserCloseTool extends BaseDeclarativeTool {
+    config;
+    static Name = ToolNames.BROWSER_CLOSE;
+    // @ts-expect-error - Required by base class pattern
+    constructor(config) {
+        super(BrowserCloseTool.Name, 'BrowserClose', 'Closes the Puppeteer-controlled browser instance. This must always be the final browser action.', Kind.Execute, {
+            type: 'object',
+            properties: {
+                force: {
+                    type: 'boolean',
+                    description: 'Whether to force close the browser',
+                },
+            },
+            required: ['force'],
+        }, false);
+        this.config = config;
+    }
+    createInvocation(params) {
+        return new BrowserCloseToolInvocation(params);
+    }
+}
+//# sourceMappingURL=browser_use.js.map