@xoxoai/checkmate 0.4.27 → 0.5.0

package/dist/drivers/web/tools/tool.d.ts

@@ -0,0 +1,76 @@
+import type { BrowserContext, Page } from 'playwright';
+import type { RuntimeLogger } from '../../../logging/types.js';
+import { AgentTool, AgentToolResponse } from '../../../tools/types.js';
+import type { BrowserStepIntent, WebToolSettings } from './types.js';
+type BrowserInputElement = {
+    ref: string;
+    text: string;
+    name: string;
+    clear: boolean;
+    select: boolean;
+};
+export declare const BrowserTool: {
+    readonly TOOL_NAVIGATE: "browser_navigate";
+    readonly TOOL_CLICK_OR_HOVER: "browser_click_or_hover";
+    readonly TOOL_SET_DIALOG_RESPONSE: "browser_set_dialog_response";
+    readonly TOOL_DRAG: "browser_drag";
+    readonly TOOL_UPLOAD: "browser_upload";
+    readonly TOOL_TYPE_OR_SELECT: "browser_type_or_select";
+    readonly TOOL_PRESS_KEY: "browser_press_key";
+    readonly TOOL_SNAPSHOT: "browser_snapshot";
+    readonly TOOL_WAIT: "browser_wait";
+    readonly TOOL_LIST_TABS: "browser_list_tabs";
+    readonly TOOL_SELECT_TAB: "browser_select_tab";
+    readonly TOOL_CLOSE_TAB: "browser_close_tab";
+    readonly TOOL_NETWORK_REQUESTS: "browser_network_requests";
+    readonly TOOL_NETWORK_REQUEST: "browser_network_request";
+};
+export declare class BrowserToolRuntime {
+    private readonly config;
+    private readonly runtimeLogger;
+    private readonly browserContext;
+    private activePage;
+    private nextPageNumber;
+    private readonly pageIds;
+    private readonly pagesById;
+    private pendingDialogHandlingIntent;
+    private readonly networkRecorder;
+    constructor(page: Page, config: WebToolSettings, runtimeLogger: RuntimeLogger);
+    getActivePage(): Page;
+    getBrowserContext(): BrowserContext;
+    listNetworkRequests(includeStatic: boolean): string;
+    inspectNetworkRequest(sequence: number, part: 'detail' | 'request-body' | 'response-body'): Promise<string>;
+    dispose(): void;
+    listPages(): Promise<string>;
+    selectPage(pageId: string, step: BrowserStepIntent): Promise<AgentToolResponse | string>;
+    closePage(pageId: string | null | undefined, step: BrowserStepIntent): Promise<AgentToolResponse | string>;
+    setDialogResponse(action: 'accept' | 'dismiss', promptText?: string): string;
+    navigateToUrl(url: string, step: BrowserStepIntent): Promise<AgentToolResponse | string>;
+    clickElement(ref: string, hover: boolean, step: BrowserStepIntent): Promise<AgentToolResponse | string>;
+    dragElement(sourceRef: string, targetRef: string, step: BrowserStepIntent): Promise<AgentToolResponse | string>;
+    uploadFiles(ref: string, filePaths: string[], step: BrowserStepIntent): Promise<AgentToolResponse | string>;
+    typeOrSelectInElement(elements: BrowserInputElement[], step: BrowserStepIntent): Promise<AgentToolResponse | string>;
+    pressKey(key: string, step: BrowserStepIntent): Promise<AgentToolResponse | string>;
+    captureCurrentSnapshot(step: BrowserStepIntent, options?: {
+        skipFilter?: boolean;
+    }): Promise<string>;
+    wait(seconds: number, step: BrowserStepIntent): Promise<AgentToolResponse | string>;
+    private consumePendingDialogHandlingIntent;
+    private registerExistingPages;
+    private registerPage;
+    ensureActivePage(): Promise<Page>;
+    private openPages;
+    private findOpenPage;
+    private setActivePage;
+    private selectFallbackActivePage;
+    private selectNewestFallbackActivePage;
+    private setNewestFallbackActivePage;
+    private selectNewPageOpenedAfter;
+    private isPageClosed;
+    private safeTitle;
+    private waitForPageEventLoop;
+    private wrapWithTracker;
+}
+export declare function createBrowserTools(runtime: BrowserToolRuntime): AgentTool[];
+export {};
+//# sourceMappingURL=tool.d.ts.map

package/dist/drivers/web/tools/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../../../src/drivers/web/tools/tool.ts"],"names":[],"mappings":"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"}

package/dist/drivers/web/tools/tool.js

@@ -0,0 +1,562 @@
+import { z } from 'zod/v4';
+import { defineAgentTool } from '../../../tools/define-agent-tool.js';
+import { NetworkRequestRecorder } from './network-request-recorder.js';
+import { SnapshotService } from './snapshot-service.js';
+import { TransientStateTracker } from './transient-state-tracker.js';
+export const BrowserTool = {
+    TOOL_NAVIGATE: 'browser_navigate',
+    TOOL_CLICK_OR_HOVER: 'browser_click_or_hover',
+    TOOL_SET_DIALOG_RESPONSE: 'browser_set_dialog_response',
+    TOOL_DRAG: 'browser_drag',
+    TOOL_UPLOAD: 'browser_upload',
+    TOOL_TYPE_OR_SELECT: 'browser_type_or_select',
+    TOOL_PRESS_KEY: 'browser_press_key',
+    TOOL_SNAPSHOT: 'browser_snapshot',
+    TOOL_WAIT: 'browser_wait',
+    TOOL_LIST_TABS: 'browser_list_tabs',
+    TOOL_SELECT_TAB: 'browser_select_tab',
+    TOOL_CLOSE_TAB: 'browser_close_tab',
+    TOOL_NETWORK_REQUESTS: 'browser_network_requests',
+    TOOL_NETWORK_REQUEST: 'browser_network_request',
+};
+const browserInputElementSchema = z
+    .object({
+    ref: z.string().describe('ref value of the element from the snapshot, example: e123'),
+    name: z.string().describe('name of the element to type into, example: Username Input'),
+    text: z.string().describe('The text to type into the element, example: Hello World'),
+    clear: z
+        .boolean()
+        .describe('If true, clears existing text before typing. Use false with dropdowns and selects'),
+    select: z.boolean().describe('If true, selects the option matching "text" from a dropdown or select element'),
+})
+    .strict();
+const dialogResponseSchema = z
+    .object({
+    action: z.enum(['accept', 'dismiss']).describe('How to answer the next JavaScript alert, confirm, or prompt'),
+    promptText: z.string().nullable().describe('Text to submit when accepting a prompt() dialog'),
+    goal: z.string().describe('The goal or purpose of handling the next dialog'),
+})
+    .strict();
+export class BrowserToolRuntime {
+    config;
+    runtimeLogger;
+    browserContext;
+    activePage;
+    nextPageNumber = 1;
+    pageIds = new Map();
+    pagesById = new Map();
+    pendingDialogHandlingIntent = null;
+    networkRecorder;
+    constructor(page, config, runtimeLogger) {
+        this.config = config;
+        this.runtimeLogger = runtimeLogger;
+        this.browserContext = page.context();
+        this.activePage = page;
+        this.networkRecorder = new NetworkRequestRecorder(this.browserContext);
+        this.networkRecorder.attach();
+        this.registerExistingPages();
+        this.setActivePage(page);
+        this.browserContext.on('page', (newPage) => {
+            this.registerPage(newPage);
+            this.setActivePage(newPage);
+        });
+    }
+    getActivePage() {
+        if (this.isPageClosed(this.activePage)) {
+            this.selectNewestFallbackActivePage();
+        }
+        if (this.isPageClosed(this.activePage)) {
+            throw new Error('No open browser pages remain in this context.');
+        }
+        return this.activePage;
+    }
+    getBrowserContext() {
+        return this.browserContext;
+    }
+    listNetworkRequests(includeStatic) {
+        return this.networkRecorder.format({ includeStatic }) || 'No API calls were made since the last browser action.';
+    }
+    async inspectNetworkRequest(sequence, part) {
+        if (part === 'detail') {
+            return this.networkRecorder.detail(sequence);
+        }
+        return this.networkRecorder.body(sequence, part === 'request-body' ? 'request' : 'response');
+    }
+    dispose() {
+        this.networkRecorder.detach();
+    }
+    async listPages() {
+        await this.ensureActivePage();
+        const pages = await this.openPages();
+        if (pages.length === 0) {
+            return 'No open browser tabs.';
+        }
+        const lines = await Promise.all(pages.map(async (page) => {
+            const id = this.registerPage(page);
+            const marker = page === this.getActivePage() ? ' (active)' : '';
+            return `${id}${marker}: ${page.url()} - ${await this.safeTitle(page)}`;
+        }));
+        return [`Open browser tabs:`, ...lines].join('\n');
+    }
+    async selectPage(pageId, step) {
+        const page = await this.findOpenPage(pageId);
+        if (!page) {
+            return `Browser tab '${pageId}' was not found or is closed.`;
+        }
+        await this.setActivePage(page);
+        return {
+            response: `Selected browser tab ${pageId}: ${page.url()}`,
+            snapshot: await this.captureCurrentSnapshot(step),
+        };
+    }
+    async closePage(pageId, step) {
+        const pages = await this.openPages();
+        if (pages.length <= 1) {
+            return 'Cannot close the last open browser tab.';
+        }
+        const page = pageId ? await this.findOpenPage(pageId) : await this.ensureActivePage();
+        if (!page || this.isPageClosed(page)) {
+            return `Browser tab '${pageId}' was not found or is closed.`;
+        }
+        const closedId = this.registerPage(page);
+        await page.close();
+        await this.selectFallbackActivePage(page);
+        const activePage = this.getActivePage();
+        const activeId = this.registerPage(activePage);
+        return {
+            response: `Closed browser tab ${closedId}. Active tab is now ${activeId}: ${activePage.url()}`,
+            snapshot: await this.captureCurrentSnapshot(step),
+        };
+    }
+    setDialogResponse(action, promptText) {
+        if (action === 'dismiss') {
+            this.pendingDialogHandlingIntent = { action };
+            return 'Will dismiss the next JavaScript dialog.';
+        }
+        this.pendingDialogHandlingIntent = promptText === undefined ? { action } : { action, promptText };
+        return promptText === undefined
+            ? 'Will accept the next JavaScript dialog.'
+            : 'Will accept the next JavaScript dialog with prompt text.';
+    }
+    async navigateToUrl(url, step) {
+        return this.wrapWithTracker(async (page) => {
+            if (!url) {
+                throw new Error(`valid URL is required for ${BrowserTool.TOOL_NAVIGATE} but received: '${url}'`);
+            }
+            try {
+                await page.goto(url);
+            }
+            catch (error) {
+                throw new Error(`Failed to navigate to URL ${url}`, { cause: error });
+            }
+        }, `Navigated to: ${url}`, step);
+    }
+    async clickElement(ref, hover, step) {
+        return this.wrapWithTracker(async (page) => {
+            try {
+                if (hover) {
+                    await page.hover(`aria-ref=${ref}`);
+                }
+                else {
+                    await page.click(`aria-ref=${ref}`);
+                }
+            }
+            catch (error) {
+                this.runtimeLogger.error(`error clicking element with ref '${ref}' due to:\n${error}`);
+                return `failed to click element with ref '${ref}':\n${error} try with different element type or ref`;
+            }
+        }, hover ? `Hovered element with ref '${ref}'.` : `Clicked element with ref '${ref}'.`, step);
+    }
+    async dragElement(sourceRef, targetRef, step) {
+        return this.wrapWithTracker(async (page) => {
+            try {
+                if (!sourceRef || !targetRef) {
+                    throw new Error(`both 'sourceRef' and 'targetRef' are required for ${BrowserTool.TOOL_DRAG} but received sourceRef='${sourceRef}' and targetRef='${targetRef}'`);
+                }
+                const source = page.locator(`aria-ref=${sourceRef}`);
+                const target = page.locator(`aria-ref=${targetRef}`);
+                await source.dragTo(target);
+            }
+            catch (error) {
+                this.runtimeLogger.error(`error dragging element with ref '${sourceRef}' to element with ref '${targetRef}' due to:\n${error}`);
+                return `failed to drag element with ref '${sourceRef}' to element with ref '${targetRef}':\n${error}\n try with different element type or ref`;
+            }
+        }, `Dragged element with ref '${sourceRef}' to element with ref '${targetRef}'.`, step);
+    }
+    async uploadFiles(ref, filePaths, step) {
+        return this.wrapWithTracker(async (page) => {
+            try {
+                if (!ref || filePaths.length === 0 || filePaths.some((filePath) => !filePath)) {
+                    throw new Error(`'ref' and at least one file path are required for ${BrowserTool.TOOL_UPLOAD} but received ref='${ref}' and filePaths='${filePaths.join(', ')}'`);
+                }
+                await page.locator(`aria-ref=${ref}`).setInputFiles(filePaths);
+            }
+            catch (error) {
+                this.runtimeLogger.error(`error uploading files to element with ref '${ref}' due to:\n${error}`);
+                return `failed to upload files to element with ref '${ref}':\n${error}\n try with different element type, ref, or file path`;
+            }
+        }, `Uploaded ${filePaths.length} file${filePaths.length === 1 ? '' : 's'} to element with ref '${ref}'.`, step);
+    }
+    async typeOrSelectInElement(elements, step) {
+        return this.wrapWithTracker(async (page) => {
+            for (const element of elements) {
+                try {
+                    if (!element.ref || element.text === undefined || element.text === null) {
+                        throw new Error(`both 'ref' and 'text' are required for ${BrowserTool.TOOL_TYPE_OR_SELECT} but received ref='${element.ref}' and text='${element.text}'`);
+                    }
+                    if (!element.select && element.clear) {
+                        await page.locator(`aria-ref=${element.ref}`).clear();
+                    }
+                    if (element.select && element.text.length > 0) {
+                        await page.locator(`aria-ref=${element.ref}`).selectOption(element.text);
+                        continue;
+                    }
+                    if (!element.select && element.text.length > 0) {
+                        await page.locator(`aria-ref=${element.ref}`).pressSequentially(element.text, { delay: 50 });
+                    }
+                }
+                catch (error) {
+                    this.runtimeLogger.error(`error ${element.select ? 'selecting' : 'typing'} '${element.text}' in element with ref '${element.ref}' due to:\n${error}`);
+                    return `failed to ${element.select ? 'select' : 'type'} '${element.text}' in element with ref '${element.ref}':\n${error}\n try with different element type or ref`;
+                }
+            }
+        }, `Updated ${elements.length} page element${elements.length === 1 ? '' : 's'}.`, step);
+    }
+    async pressKey(key, step) {
+        return this.wrapWithTracker(async (page) => {
+            try {
+                if (!key) {
+                    throw new Error(`'key' is required for ${BrowserTool.TOOL_PRESS_KEY} but received: '${key}'`);
+                }
+                await page.keyboard.press(key);
+            }
+            catch (error) {
+                this.runtimeLogger.error(`error pressing key '${key}' due to:\n${error}`);
+                return `failed to press key '${key}':\n${error}`;
+            }
+        }, `Pressed key '${key}'.`, step);
+    }
+    async captureCurrentSnapshot(step, options = {}) {
+        const page = await this.ensureActivePage();
+        return new SnapshotService(page, this.config, this.runtimeLogger, step, {
+            skipFilter: options.skipFilter,
+        }).get();
+    }
+    async wait(seconds, step) {
+        return this.wrapWithTracker(async (page) => {
+            try {
+                if (!Number.isFinite(seconds) || seconds <= 0) {
+                    throw new Error(`invalid seconds value received: ${seconds}. It should be a positive number.`);
+                }
+                await page.waitForTimeout(seconds * 1000);
+            }
+            catch (error) {
+                this.runtimeLogger.error(`error waiting for ${seconds} seconds due to:\n${error}`);
+                return `failed to wait for ${seconds} seconds:\n${error}`;
+            }
+        }, `Waited ${seconds} seconds.`, step);
+    }
+    consumePendingDialogHandlingIntent() {
+        const intent = this.pendingDialogHandlingIntent;
+        this.pendingDialogHandlingIntent = null;
+        return intent;
+    }
+    registerExistingPages() {
+        for (const page of this.browserContext.pages()) {
+            this.registerPage(page);
+        }
+    }
+    registerPage(page) {
+        const existingId = this.pageIds.get(page);
+        if (existingId) {
+            return existingId;
+        }
+        const id = `p${this.nextPageNumber++}`;
+        this.pageIds.set(page, id);
+        this.pagesById.set(id, page);
+        return id;
+    }
+    async ensureActivePage() {
+        if (this.isPageClosed(this.activePage)) {
+            await this.selectFallbackActivePage(this.activePage);
+        }
+        return this.getActivePage();
+    }
+    async openPages() {
+        this.registerExistingPages();
+        const pages = this.browserContext.pages().filter((page) => !this.isPageClosed(page));
+        for (const page of pages) {
+            this.registerPage(page);
+        }
+        if (pages.length > 0 && this.isPageClosed(this.activePage)) {
+            await this.selectFallbackActivePage(this.activePage);
+        }
+        return pages;
+    }
+    async findOpenPage(pageId) {
+        await this.openPages();
+        const page = this.pagesById.get(pageId);
+        return page && !this.isPageClosed(page) ? page : null;
+    }
+    async setActivePage(page) {
+        this.registerPage(page);
+        this.activePage = page;
+        await page.bringToFront().catch(() => undefined);
+    }
+    async selectFallbackActivePage(closedPage) {
+        const opener = await closedPage.opener().catch(() => null);
+        if (opener && !this.isPageClosed(opener)) {
+            await this.setActivePage(opener);
+            return;
+        }
+        await this.setNewestFallbackActivePage();
+    }
+    selectNewestFallbackActivePage() {
+        const page = this.browserContext
+            .pages()
+            .filter((candidate) => !this.isPageClosed(candidate))
+            .at(-1);
+        if (page) {
+            this.registerPage(page);
+            this.activePage = page;
+        }
+    }
+    async setNewestFallbackActivePage() {
+        this.selectNewestFallbackActivePage();
+        if (!this.isPageClosed(this.activePage)) {
+            await this.setActivePage(this.activePage);
+        }
+    }
+    async selectNewPageOpenedAfter(knownPages) {
+        await this.waitForPageEventLoop();
+        this.registerExistingPages();
+        const activePage = this.getActivePage();
+        const newPage = !knownPages.has(activePage)
+            ? activePage
+            : this.browserContext
+                .pages()
+                .filter((page) => !knownPages.has(page) && !this.isPageClosed(page))
+                .at(-1);
+        if (!newPage) {
+            return '';
+        }
+        await this.setActivePage(newPage);
+        await newPage.waitForLoadState('domcontentloaded', { timeout: 2_000 }).catch(() => undefined);
+        const id = this.registerPage(newPage);
+        return `Opened new tab ${id}: ${newPage.url()}. Active tab is now ${id}.`;
+    }
+    isPageClosed(page) {
+        return page.isClosed();
+    }
+    async safeTitle(page) {
+        return page.title().catch(() => '');
+    }
+    async waitForPageEventLoop() {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+    async wrapWithTracker(action, fallbackResponse, step) {
+        const page = await this.ensureActivePage();
+        const knownPages = new Set(this.browserContext.pages());
+        this.networkRecorder.reset();
+        const tracker = new TransientStateTracker(page, {
+            consumeDialogHandlingIntent: () => this.consumePendingDialogHandlingIntent(),
+            logger: this.runtimeLogger,
+        });
+        await tracker.start();
+        try {
+            const actionResult = await action(page);
+            const tabChangeResponse = await this.selectNewPageOpenedAfter(knownPages);
+            if (typeof actionResult === 'string') {
+                await tracker.stop();
+                return tabChangeResponse ? `${tabChangeResponse}\n${actionResult}` : actionResult;
+            }
+            const snapshot = await this.captureCurrentSnapshot(step);
+            await tracker.stop();
+            const formattedTimeline = tracker.formatTimeline();
+            const response = formattedTimeline || fallbackResponse;
+            return { response: tabChangeResponse ? `${tabChangeResponse}\n${response}` : response, snapshot };
+        }
+        catch (error) {
+            await tracker.stop();
+            throw error;
+        }
+        finally {
+            this.pendingDialogHandlingIntent = null;
+        }
+    }
+}
+export function createBrowserTools(runtime) {
+    return [
+        defineAgentTool({
+            name: BrowserTool.TOOL_NAVIGATE,
+            description: 'Navigate to a specified URL in the browser, example: https://www.example.com',
+            schema: z
+                .object({
+                url: z.string().describe('The URL to navigate to'),
+                goal: z.string().describe('The goal or purpose of navigating to this URL'),
+            })
+                .strict(),
+            handler: ({ url }, context) => runtime.navigateToUrl(url, context.step),
+        }),
+        defineAgentTool({
+            name: BrowserTool.TOOL_CLICK_OR_HOVER,
+            description: 'Click or hover a specified element reference in the browser',
+            schema: z
+                .object({
+                ref: z.string().describe('ref value of the element from the snapshot, example: e123'),
+                name: z.string().describe('name of the element to click or hover, example: Submit Button'),
+                hover: z.boolean().describe('If true: hover the element, if false: click element'),
+                goal: z.string().describe('The goal or purpose of clicking this element'),
+            })
+                .strict(),
+            handler: ({ ref, hover }, context) => runtime.clickElement(ref, hover, context.step),
+        }),
+        defineAgentTool({
+            name: BrowserTool.TOOL_SET_DIALOG_RESPONSE,
+            description: 'Set how to answer the next JavaScript alert, confirm, or prompt. Call this immediately before the browser action expected to open the dialog. Unarmed dialogs are dismissed automatically.',
+            schema: dialogResponseSchema,
+            handler: ({ action, promptText }) => runtime.setDialogResponse(action, promptText),
+        }),
+        defineAgentTool({
+            name: BrowserTool.TOOL_DRAG,
+            description: 'Drag a source element onto a target or drop element in the browser',
+            schema: z
+                .object({
+                sourceRef: z.string().describe('ref value of the element to drag from the snapshot, example: e123'),
+                sourceName: z.string().describe('name of the element to drag, example: File card'),
+                targetRef: z.string().describe('ref value of the drop target from the snapshot, example: e456'),
+                targetName: z.string().describe('name of the element to drop onto, example: Done column'),
+                goal: z.string().describe('The goal or purpose of dragging this element'),
+            })
+                .strict(),
+            handler: ({ sourceRef, targetRef }, context) => runtime.dragElement(sourceRef, targetRef, context.step),
+        }),
+        defineAgentTool({
+            name: BrowserTool.TOOL_UPLOAD,
+            description: 'Upload one or more local files to a file input element in the browser',
+            schema: z
+                .object({
+                ref: z.string().describe('ref value of the file input element from the snapshot, example: e123'),
+                name: z.string().describe('name of the file input element, example: Resume Upload'),
+                filePaths: z
+                    .array(z.string())
+                    .min(1)
+                    .describe('local file paths to upload, example: ["fixtures/resume.pdf"]'),
+                goal: z.string().describe('The goal or purpose of uploading these files'),
+            })
+                .strict(),
+            handler: ({ ref, filePaths }, context) => runtime.uploadFiles(ref, filePaths, context.step),
+        }),
+        defineAgentTool({
+            name: BrowserTool.TOOL_TYPE_OR_SELECT,
+            description: 'Type text into a specified element reference in the browser or select an option from a dropdown.',
+            schema: z
+                .object({
+                elements: z.array(browserInputElementSchema).min(1).describe('array of elements to type into'),
+                goal: z.string().describe('The goal or purpose of typing this text into the element'),
+            })
+                .strict(),
+            handler: ({ elements }, context) => runtime.typeOrSelectInElement(elements, context.step),
+        }),
+        defineAgentTool({
+            name: BrowserTool.TOOL_PRESS_KEY,
+            description: 'Press a specified key in the browser',
+            schema: z
+                .object({
+                key: z.string().describe('The key to press, example: Enter, Escape, ArrowDown'),
+                goal: z.string().describe('The goal or purpose of pressing this key'),
+            })
+                .strict(),
+            handler: ({ key }, context) => runtime.pressKey(key, context.step),
+        }),
+        defineAgentTool({
+            name: BrowserTool.TOOL_SNAPSHOT,
+            description: 'Capture the ARIA snapshot of the current page - use only if you miss information from previous snapshot.',
+            schema: z
+                .object({
+                goal: z.string().describe('The goal or purpose of capturing the snapshot'),
+            })
+                .strict(),
+            handler: async (_args, context) => ({
+                response: 'Captured latest page snapshot.',
+                snapshot: await runtime.captureCurrentSnapshot(context.step, { skipFilter: true }),
+            }),
+        }),
+        defineAgentTool({
+            name: BrowserTool.TOOL_WAIT,
+            description: 'Wait for a timeout in seconds',
+            schema: z
+                .object({
+                seconds: z.number().describe('Number of seconds to wait, example: 5'),
+                goal: z.string().describe('The goal or purpose of waiting'),
+            })
+                .strict(),
+            handler: ({ seconds }, context) => runtime.wait(seconds, context.step),
+        }),
+        defineAgentTool({
+            name: BrowserTool.TOOL_LIST_TABS,
+            description: 'List open browser tabs and show which tab is active',
+            schema: z
+                .object({
+                goal: z.string().describe('The goal or purpose of listing browser tabs'),
+            })
+                .strict(),
+            handler: () => runtime.listPages(),
+        }),
+        defineAgentTool({
+            name: BrowserTool.TOOL_SELECT_TAB,
+            description: 'Select an open browser tab by pageId and make it active',
+            schema: z
+                .object({
+                pageId: z.string().describe('Browser tab id from browser_list_tabs, example: p2'),
+                goal: z.string().describe('The goal or purpose of selecting this browser tab'),
+            })
+                .strict(),
+            handler: ({ pageId }, context) => runtime.selectPage(pageId, context.step),
+        }),
+        defineAgentTool({
+            name: BrowserTool.TOOL_CLOSE_TAB,
+            description: 'Close a browser tab by pageId, or close the active tab when pageId is null',
+            schema: z
+                .object({
+                pageId: z
+                    .string()
+                    .nullable()
+                    .describe('Browser tab id from browser_list_tabs, or null for active tab'),
+                goal: z.string().describe('The goal or purpose of closing this browser tab'),
+            })
+                .strict(),
+            handler: ({ pageId }, context) => runtime.closePage(pageId, context.step),
+        }),
+        defineAgentTool({
+            name: BrowserTool.TOOL_NETWORK_REQUESTS,
+            description: "List the API calls (fetch/XHR) the browser made during the last browser action only - call this again after each new action to see its calls. Set 'static' to true to also include images, fonts, and other non-API resources.",
+            schema: z
+                .object({
+                static: z
+                    .boolean()
+                    .describe('If true, also include non-API resource types like images, fonts, and stylesheets'),
+                goal: z.string().describe('The goal or purpose of listing network requests'),
+            })
+                .strict(),
+            handler: ({ static: includeStatic }) => runtime.listNetworkRequests(includeStatic),
+        }),
+        defineAgentTool({
+            name: BrowserTool.TOOL_NETWORK_REQUEST,
+            description: 'Inspect one network request from the most recent browser_network_requests result, using its number. Only valid until the next browser action resets the list.',
+            schema: z
+                .object({
+                sequence: z
+                    .number()
+                    .describe('The number of the request from browser_network_requests, example: 1'),
+                part: z
+                    .enum(['detail', 'request-body', 'response-body'])
+                    .describe("What to return: 'detail' for headers and timing, or the request/response body"),
+                goal: z.string().describe('The goal or purpose of inspecting this network request'),
+            })
+                .strict(),
+            handler: ({ sequence, part }) => runtime.inspectNetworkRequest(sequence, part),
+        }),
+    ];
+}
+//# sourceMappingURL=tool.js.map