@mastra/agent-browser 0.4.1 → 0.5.0-alpha.0

package/dist/index.js

@@ -1,1779 +1,1656 @@
-import { ThreadManager, MastraBrowser, DEFAULT_THREAD_ID, createBrowserRecordingTools, ScreencastStreamImpl } from '@mastra/core/browser';
-import { BrowserManager } from 'agent-browser';
-import { createTool } from '@mastra/core/tools';
-import { z } from 'zod';
-
-// src/agent-browser.ts
+import { DEFAULT_THREAD_ID, MastraBrowser, ScreencastStreamImpl, ThreadManager, createBrowserRecordingTools } from "@mastra/core/browser";
+import { BrowserManager } from "agent-browser";
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+//#region src/thread-manager.ts
+/**
+* AgentBrowserThreadManager - Thread scope management for AgentBrowser
+*
+* Manages thread-scoped browser sessions using agent-browser's
+* BrowserManager capabilities (newWindow, switchTo, closeTab).
+*/
+/**
+* Thread manager implementation for AgentBrowser.
+*
+* Supports two scope modes:
+* - 'shared': All threads share the shared browser manager
+* - 'thread': Each thread gets a dedicated browser manager instance
+*/
 var AgentBrowserThreadManager = class extends ThreadManager {
-  browserConfig;
-  resolveCdpUrl;
-  onBrowserCreated;
-  constructor(config) {
-    super(config);
-    this.browserConfig = config.browserConfig;
-    this.resolveCdpUrl = config.resolveCdpUrl;
-    this.onBrowserCreated = config.onBrowserCreated;
-  }
-  /**
-   * Get the page for a specific thread, creating session if needed.
-   */
-  async getPageForThread(threadId) {
-    const manager = await this.getManagerForThread(threadId);
-    return manager.getPage();
-  }
-  /**
-   * Create a new session for a thread.
-   */
-  async createSession(threadId) {
-    const savedState = this.getSavedBrowserState(threadId);
-    const session = {
-      threadId,
-      createdAt: Date.now(),
-      browserState: savedState
-    };
-    if (this.scope === "thread") {
-      const manager = new BrowserManager();
-      const launchOptions = {
-        headless: this.browserConfig.headless,
-        viewport: this.browserConfig.viewport,
-        profile: this.browserConfig.profile,
-        executablePath: this.browserConfig.executablePath,
-        storageState: this.browserConfig.storageState
-      };
-      if (this.browserConfig.cdpUrl && this.resolveCdpUrl) {
-        launchOptions.cdpUrl = await this.resolveCdpUrl(this.browserConfig.cdpUrl);
-      }
-      try {
-        await manager.launch(launchOptions);
-      } catch (error) {
-        try {
-          await manager.close();
-        } catch {
-        }
-        throw error;
-      }
-      session.manager = manager;
-      this.threadManagers.set(threadId, manager);
-      try {
-        if (savedState && savedState.tabs.length > 0) {
-          this.logger?.debug?.(`Restoring browser state for thread ${threadId}: ${savedState.tabs.length} tabs`);
-          await this.restoreBrowserState(manager, savedState);
-        }
-        this.onBrowserCreated?.(manager, threadId);
-      } catch (error) {
-        this.threadManagers.delete(threadId);
-        session.manager = void 0;
-        try {
-          await manager.close();
-        } catch {
-        }
-        throw error;
-      }
-    }
-    return session;
-  }
-  /**
-   * Restore browser state (multiple tabs) to a browser manager.
-   */
-  async restoreBrowserState(manager, state) {
-    try {
-      const firstTab = state.tabs[0];
-      if (firstTab?.url) {
-        const page = manager.getPage();
-        if (page) {
-          await page.goto(firstTab.url, { waitUntil: "domcontentloaded" });
-        }
-      }
-      for (let i = 1; i < state.tabs.length; i++) {
-        const tab = state.tabs[i];
-        if (tab?.url) {
-          await manager.newTab();
-          const page = manager.getPage();
-          if (page) {
-            await page.goto(tab.url, { waitUntil: "domcontentloaded" });
-          }
-        }
-      }
-      if (state.tabs.length > 1 && state.activeTabIndex >= 0 && state.activeTabIndex < state.tabs.length) {
-        await manager.switchTo(state.activeTabIndex);
-      }
-    } catch (error) {
-      this.logger?.warn?.(`Failed to restore browser state: ${error}`);
-    }
-  }
-  /**
-   * Get the browser manager for a specific session.
-   */
-  getManagerForSession(session) {
-    if (this.scope === "thread" && session.manager) {
-      return session.manager;
-    }
-    return this.getSharedManager();
-  }
-  /**
-   * Destroy a session and clean up resources.
-   */
-  async doDestroySession(session) {
-    if (this.scope === "thread" && session.manager) {
-      await session.manager.close();
-    }
-  }
-  /**
-   * Destroy all sessions (called during browser close).
-   * doDestroySession handles closing individual browser managers.
-   */
-  async destroyAllSessions() {
-    await super.destroyAllSessions();
-  }
+	browserConfig;
+	resolveCdpUrl;
+	onBrowserCreated;
+	constructor(config) {
+		super(config);
+		this.browserConfig = config.browserConfig;
+		this.resolveCdpUrl = config.resolveCdpUrl;
+		this.onBrowserCreated = config.onBrowserCreated;
+	}
+	/**
+	* Get the page for a specific thread, creating session if needed.
+	*/
+	async getPageForThread(threadId) {
+		return (await this.getManagerForThread(threadId)).getPage();
+	}
+	/**
+	* Create a new session for a thread.
+	*/
+	async createSession(threadId) {
+		const savedState = this.getSavedBrowserState(threadId);
+		const session = {
+			threadId,
+			createdAt: Date.now(),
+			browserState: savedState
+		};
+		if (this.scope === "thread") {
+			const manager = new BrowserManager();
+			const launchOptions = {
+				headless: this.browserConfig.headless,
+				viewport: this.browserConfig.viewport,
+				profile: this.browserConfig.profile,
+				executablePath: this.browserConfig.executablePath,
+				storageState: this.browserConfig.storageState
+			};
+			if (this.browserConfig.cdpUrl && this.resolveCdpUrl) launchOptions.cdpUrl = await this.resolveCdpUrl(this.browserConfig.cdpUrl);
+			if (this.browserConfig.cdpHeaders) launchOptions.cdpHeaders = this.browserConfig.cdpHeaders;
+			try {
+				await manager.launch(launchOptions);
+			} catch (error) {
+				try {
+					await manager.close();
+				} catch {}
+				throw error;
+			}
+			session.manager = manager;
+			this.threadManagers.set(threadId, manager);
+			try {
+				if (savedState && savedState.tabs.length > 0) {
+					this.logger?.debug?.(`Restoring browser state for thread ${threadId}: ${savedState.tabs.length} tabs`);
+					await this.restoreBrowserState(manager, savedState);
+				}
+				this.onBrowserCreated?.(manager, threadId);
+			} catch (error) {
+				this.threadManagers.delete(threadId);
+				session.manager = void 0;
+				try {
+					await manager.close();
+				} catch {}
+				throw error;
+			}
+		}
+		return session;
+	}
+	/**
+	* Restore browser state (multiple tabs) to a browser manager.
+	*/
+	async restoreBrowserState(manager, state) {
+		try {
+			const firstTab = state.tabs[0];
+			if (firstTab?.url) {
+				const page = manager.getPage();
+				if (page) await page.goto(firstTab.url, { waitUntil: "domcontentloaded" });
+			}
+			for (let i = 1; i < state.tabs.length; i++) {
+				const tab = state.tabs[i];
+				if (tab?.url) {
+					await manager.newTab();
+					const page = manager.getPage();
+					if (page) await page.goto(tab.url, { waitUntil: "domcontentloaded" });
+				}
+			}
+			if (state.tabs.length > 1 && state.activeTabIndex >= 0 && state.activeTabIndex < state.tabs.length) await manager.switchTo(state.activeTabIndex);
+		} catch (error) {
+			this.logger?.warn?.(`Failed to restore browser state: ${error}`);
+		}
+	}
+	/**
+	* Get the browser manager for a specific session.
+	*/
+	getManagerForSession(session) {
+		if (this.scope === "thread" && session.manager) return session.manager;
+		return this.getSharedManager();
+	}
+	/**
+	* Destroy a session and clean up resources.
+	*/
+	async doDestroySession(session) {
+		if (this.scope === "thread" && session.manager) await session.manager.close();
+	}
+	/**
+	* Destroy all sessions (called during browser close).
+	* doDestroySession handles closing individual browser managers.
+	*/
+	async destroyAllSessions() {
+		await super.destroyAllSessions();
+	}
 };
-var gotoInputSchema = z.object({
-  url: z.string().describe("The URL to navigate to"),
-  waitUntil: z.enum(["load", "domcontentloaded", "networkidle"]).optional().describe("When to consider navigation complete (default: domcontentloaded)"),
-  timeout: z.number().optional().describe("Navigation timeout in milliseconds")
+//#endregion
+//#region src/schemas.ts
+/**
+* AgentBrowser Tool Schemas
+*
+* Flat schemas for browser tools. Each tool has a single-purpose schema
+* without discriminated unions, making them easier for LLMs to understand.
+*
+* Tools:
+* - Core: goto, snapshot, click, type, press, select, scroll, close
+* - Extended: hover, back, dialog, wait, tabs, drag
+* - Escape Hatch: evaluate
+*/
+/**
+* browser_goto - Navigate to a URL
+*/
+const gotoInputSchema = z.object({
+	url: z.string().describe("The URL to navigate to"),
+	waitUntil: z.enum([
+		"load",
+		"domcontentloaded",
+		"networkidle"
+	]).optional().describe("When to consider navigation complete (default: domcontentloaded)"),
+	timeout: z.number().optional().describe("Navigation timeout in milliseconds")
 });
-var snapshotInputSchema = z.object({
-  interactiveOnly: z.boolean().optional().describe("Only include interactive elements (default: true)"),
-  maxDepth: z.number().optional().describe("Maximum depth of the tree to return")
+/**
+* browser_snapshot - Get accessibility tree snapshot
+*/
+const snapshotInputSchema = z.object({
+	interactiveOnly: z.boolean().optional().describe("Only include interactive elements (default: true)"),
+	maxDepth: z.number().optional().describe("Maximum depth of the tree to return")
 });
-var clickInputSchema = z.object({
-  ref: z.string().describe("Element ref from snapshot (e.g., @e5)"),
-  button: z.enum(["left", "right", "middle"]).optional().describe("Mouse button (default: left)"),
-  clickCount: z.number().optional().describe("Number of clicks (default: 1, use 2 for double-click)"),
-  modifiers: z.array(z.enum(["Alt", "Control", "Meta", "Shift"])).optional().describe("Modifier keys to hold"),
-  waitUntil: z.enum(["load", "domcontentloaded", "networkidle"]).optional().describe("If the click triggers a navigation, wait for this page load state before returning"),
-  timeout: z.number().nonnegative().optional().describe("Timeout in milliseconds for the click and optional waitUntil")
+/**
+* browser_click - Click an element
+*/
+const clickInputSchema = z.object({
+	ref: z.string().describe("Element ref from snapshot (e.g., @e5)"),
+	button: z.enum([
+		"left",
+		"right",
+		"middle"
+	]).optional().describe("Mouse button (default: left)"),
+	clickCount: z.number().optional().describe("Number of clicks (default: 1, use 2 for double-click)"),
+	modifiers: z.array(z.enum([
+		"Alt",
+		"Control",
+		"Meta",
+		"Shift"
+	])).optional().describe("Modifier keys to hold"),
+	waitUntil: z.enum([
+		"load",
+		"domcontentloaded",
+		"networkidle"
+	]).optional().describe("If the click triggers a navigation, wait for this page load state before returning"),
+	timeout: z.number().nonnegative().optional().describe("Timeout in milliseconds for the click and optional waitUntil")
 });
-var typeInputSchema = z.object({
-  ref: z.string().describe("Element ref from snapshot"),
-  text: z.string().describe("Text to type"),
-  clear: z.boolean().optional().describe("Clear existing content before typing (default: false)"),
-  delay: z.number().optional().describe("Delay between keystrokes in ms")
+/**
+* browser_type - Type text into an element
+*/
+const typeInputSchema = z.object({
+	ref: z.string().describe("Element ref from snapshot"),
+	text: z.string().describe("Text to type"),
+	clear: z.boolean().optional().describe("Clear existing content before typing (default: false)"),
+	delay: z.number().optional().describe("Delay between keystrokes in ms")
 });
-var pressInputSchema = z.object({
-  key: z.string().describe("Key to press (e.g., Enter, Tab, Escape, Control+a)"),
-  modifiers: z.array(z.enum(["Alt", "Control", "Meta", "Shift"])).optional().describe("Modifier keys to hold"),
-  waitUntil: z.enum(["load", "domcontentloaded", "networkidle"]).optional().describe("If the key press triggers a navigation, wait for this page load state before returning"),
-  timeout: z.number().nonnegative().optional().describe("Timeout in milliseconds for the optional waitUntil")
+/**
+* browser_press - Press a keyboard key
+*/
+const pressInputSchema = z.object({
+	key: z.string().describe("Key to press (e.g., Enter, Tab, Escape, Control+a)"),
+	modifiers: z.array(z.enum([
+		"Alt",
+		"Control",
+		"Meta",
+		"Shift"
+	])).optional().describe("Modifier keys to hold"),
+	waitUntil: z.enum([
+		"load",
+		"domcontentloaded",
+		"networkidle"
+	]).optional().describe("If the key press triggers a navigation, wait for this page load state before returning"),
+	timeout: z.number().nonnegative().optional().describe("Timeout in milliseconds for the optional waitUntil")
 });
-var selectInputSchema = z.object({
-  ref: z.string().describe("Select element ref from snapshot"),
-  value: z.string().optional().describe("Option value to select"),
-  label: z.string().optional().describe("Option label to select"),
-  index: z.number().int().min(0).optional().describe("Option index to select (0-based)"),
-  waitUntil: z.enum(["load", "domcontentloaded", "networkidle"]).optional().describe("If the selection triggers a navigation, wait for this page load state before returning"),
-  timeout: z.number().nonnegative().optional().describe("Timeout in milliseconds for the selection and optional waitUntil")
+/**
+* browser_select - Select option from dropdown
+*/
+const selectInputSchema = z.object({
+	ref: z.string().describe("Select element ref from snapshot"),
+	value: z.string().optional().describe("Option value to select"),
+	label: z.string().optional().describe("Option label to select"),
+	index: z.number().int().min(0).optional().describe("Option index to select (0-based)"),
+	waitUntil: z.enum([
+		"load",
+		"domcontentloaded",
+		"networkidle"
+	]).optional().describe("If the selection triggers a navigation, wait for this page load state before returning"),
+	timeout: z.number().nonnegative().optional().describe("Timeout in milliseconds for the selection and optional waitUntil")
 }).superRefine((data, ctx) => {
-  if (data.value === void 0 && data.label === void 0 && data.index === void 0) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "At least one of value, label, or index is required"
-    });
-  }
-});
-var scrollInputSchema = z.object({
-  direction: z.enum(["up", "down", "left", "right"]).describe("Scroll direction"),
-  amount: z.number().optional().describe("Scroll amount in pixels (default: 300)"),
-  ref: z.string().optional().describe("Element ref to scroll (scrolls page if omitted)")
+	if (data.value === void 0 && data.label === void 0 && data.index === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "At least one of value, label, or index is required"
+	});
 });
-var closeInputSchema = z.object({});
-var hoverInputSchema = z.object({
-  ref: z.string().describe("Element ref from snapshot")
+/**
+* browser_scroll - Scroll the page or element
+*/
+const scrollInputSchema = z.object({
+	direction: z.enum([
+		"up",
+		"down",
+		"left",
+		"right"
+	]).describe("Scroll direction"),
+	amount: z.number().optional().describe("Scroll amount in pixels (default: 300)"),
+	ref: z.string().optional().describe("Element ref to scroll (scrolls page if omitted)")
 });
-var backInputSchema = z.object({});
-var dialogInputSchema = z.object({
-  triggerRef: z.string().describe("Element ref that triggers the dialog (e.g., @e5)"),
-  action: z.enum(["accept", "dismiss"]).describe("Accept or dismiss the dialog"),
-  text: z.string().optional().describe("Text to enter for prompt dialogs")
+/**
+* browser_close - Close the browser
+*/
+const closeInputSchema = z.object({});
+/**
+* browser_hover - Hover over an element
+*/
+const hoverInputSchema = z.object({ ref: z.string().describe("Element ref from snapshot") });
+/**
+* browser_back - Go back in browser history
+*/
+const backInputSchema = z.object({});
+/**
+* browser_dialog - Click an element that triggers a dialog and handle it
+*/
+const dialogInputSchema = z.object({
+	triggerRef: z.string().describe("Element ref that triggers the dialog (e.g., @e5)"),
+	action: z.enum(["accept", "dismiss"]).describe("Accept or dismiss the dialog"),
+	text: z.string().optional().describe("Text to enter for prompt dialogs")
 });
-var waitInputSchema = z.object({
-  ref: z.string().optional().describe("Element ref to wait for"),
-  state: z.enum(["visible", "hidden", "attached", "detached"]).optional().describe("State to wait for (default: visible)"),
-  timeout: z.number().optional().describe("Maximum wait time in ms (default: 30000)")
+/**
+* browser_wait - Wait for an element or condition
+*/
+const waitInputSchema = z.object({
+	ref: z.string().optional().describe("Element ref to wait for"),
+	state: z.enum([
+		"visible",
+		"hidden",
+		"attached",
+		"detached"
+	]).optional().describe("State to wait for (default: visible)"),
+	timeout: z.number().optional().describe("Maximum wait time in ms (default: 30000)")
 });
-var tabsInputSchema = z.object({
-  action: z.enum(["list", "new", "switch", "close"]).describe("Tab action"),
-  index: z.number().int().min(0).optional().describe("Tab index for switch/close"),
-  url: z.string().optional().describe("URL to open in new tab")
+/**
+* browser_tabs - Manage browser tabs
+*/
+const tabsInputSchema = z.object({
+	action: z.enum([
+		"list",
+		"new",
+		"switch",
+		"close"
+	]).describe("Tab action"),
+	index: z.number().int().min(0).optional().describe("Tab index for switch/close"),
+	url: z.string().optional().describe("URL to open in new tab")
 }).superRefine((value, ctx) => {
-  if (value.action === "switch" && value.index === void 0) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ["index"],
-      message: 'index is required when action is "switch"'
-    });
-  }
+	if (value.action === "switch" && value.index === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["index"],
+		message: "index is required when action is \"switch\""
+	});
 });
-var dragInputSchema = z.object({
-  sourceRef: z.string().optional().describe("Element ref to drag from (e.g., @e5)"),
-  targetRef: z.string().optional().describe("Element ref to drag to (e.g., @e7)"),
-  sourceSelector: z.string().optional().describe("CSS selector for source element (use if ref not available)"),
-  targetSelector: z.string().optional().describe("CSS selector for target element (use if ref not available)")
+/**
+* browser_drag - Drag an element to another element
+*/
+const dragInputSchema = z.object({
+	sourceRef: z.string().optional().describe("Element ref to drag from (e.g., @e5)"),
+	targetRef: z.string().optional().describe("Element ref to drag to (e.g., @e7)"),
+	sourceSelector: z.string().optional().describe("CSS selector for source element (use if ref not available)"),
+	targetSelector: z.string().optional().describe("CSS selector for target element (use if ref not available)")
 }).superRefine((data, ctx) => {
-  if (!data.sourceRef && !data.sourceSelector) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ["sourceRef"],
-      message: "Either sourceRef or sourceSelector is required"
-    });
-  }
-  if (!data.targetRef && !data.targetSelector) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ["targetRef"],
-      message: "Either targetRef or targetSelector is required"
-    });
-  }
-});
-var screenshotInputSchema = z.object({
-  fullPage: z.boolean().optional().describe("Capture the full scrollable page instead of just the viewport (default: false)")
+	if (!data.sourceRef && !data.sourceSelector) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["sourceRef"],
+		message: "Either sourceRef or sourceSelector is required"
+	});
+	if (!data.targetRef && !data.targetSelector) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["targetRef"],
+		message: "Either targetRef or targetSelector is required"
+	});
 });
-var evaluateInputSchema = z.object({
-  script: z.string().describe(
-    "JavaScript expression to evaluate in the browser and return the result. Do not use `return` \u2014 write a bare expression like `document.title` or `1 + 1`. For async code, wrap in an async IIFE: `(async () => { ... })()`."
-  ),
-  arg: z.unknown().optional().describe("Argument to pass to the script (JSON-serializable)")
+/**
+* browser_screenshot - Capture a screenshot of the current page
+*/
+const screenshotInputSchema = z.object({ fullPage: z.boolean().optional().describe("Capture the full scrollable page instead of just the viewport (default: false)") });
+/**
+* browser_evaluate - Execute JavaScript in the browser
+*/
+const evaluateInputSchema = z.object({
+	script: z.string().describe("JavaScript expression to evaluate in the browser and return the result. Do not use `return` — write a bare expression like `document.title` or `1 + 1`. For async code, wrap in an async IIFE: `(async () => { ... })()`."),
+	arg: z.unknown().optional().describe("Argument to pass to the script (JSON-serializable)")
 });
-var browserSchemas = {
-  // Core
-  goto: gotoInputSchema,
-  snapshot: snapshotInputSchema,
-  click: clickInputSchema,
-  type: typeInputSchema,
-  press: pressInputSchema,
-  select: selectInputSchema,
-  scroll: scrollInputSchema,
-  close: closeInputSchema,
-  // Extended
-  hover: hoverInputSchema,
-  back: backInputSchema,
-  dialog: dialogInputSchema,
-  wait: waitInputSchema,
-  tabs: tabsInputSchema,
-  drag: dragInputSchema,
-  // Utility
-  screenshot: screenshotInputSchema,
-  // Escape hatch
-  evaluate: evaluateInputSchema
+const browserSchemas = {
+	goto: gotoInputSchema,
+	snapshot: snapshotInputSchema,
+	click: clickInputSchema,
+	type: typeInputSchema,
+	press: pressInputSchema,
+	select: selectInputSchema,
+	scroll: scrollInputSchema,
+	close: closeInputSchema,
+	hover: hoverInputSchema,
+	back: backInputSchema,
+	dialog: dialogInputSchema,
+	wait: waitInputSchema,
+	tabs: tabsInputSchema,
+	drag: dragInputSchema,
+	screenshot: screenshotInputSchema,
+	evaluate: evaluateInputSchema
 };
-
-// src/tools/constants.ts
-var BROWSER_TOOLS = {
-  // Core
-  GOTO: "browser_goto",
-  SNAPSHOT: "browser_snapshot",
-  CLICK: "browser_click",
-  TYPE: "browser_type",
-  PRESS: "browser_press",
-  SELECT: "browser_select",
-  SCROLL: "browser_scroll",
-  CLOSE: "browser_close",
-  // Extended
-  HOVER: "browser_hover",
-  BACK: "browser_back",
-  DIALOG: "browser_dialog",
-  WAIT: "browser_wait",
-  TABS: "browser_tabs",
-  DRAG: "browser_drag",
-  // Utility
-  SCREENSHOT: "browser_screenshot",
-  // Escape hatch
-  EVALUATE: "browser_evaluate"
+//#endregion
+//#region src/tools/constants.ts
+/**
+* Browser Tool Constants
+*/
+const BROWSER_TOOLS = {
+	GOTO: "browser_goto",
+	SNAPSHOT: "browser_snapshot",
+	CLICK: "browser_click",
+	TYPE: "browser_type",
+	PRESS: "browser_press",
+	SELECT: "browser_select",
+	SCROLL: "browser_scroll",
+	CLOSE: "browser_close",
+	HOVER: "browser_hover",
+	BACK: "browser_back",
+	DIALOG: "browser_dialog",
+	WAIT: "browser_wait",
+	TABS: "browser_tabs",
+	DRAG: "browser_drag",
+	SCREENSHOT: "browser_screenshot",
+	EVALUATE: "browser_evaluate"
 };
-
-// src/tools/back.ts
+//#endregion
+//#region src/tools/back.ts
+/**
+* browser_back - Go back in browser history
+*/
 function createBackTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.BACK,
-    description: "Go back to the previous page in browser history.",
-    inputSchema: backInputSchema,
-    execute: async (_input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return browser.back(threadId);
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.BACK,
+		description: "Go back to the previous page in browser history.",
+		inputSchema: backInputSchema,
+		execute: async (_input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return browser.back(threadId);
+		}
+	});
 }
+//#endregion
+//#region src/tools/click.ts
+/**
+* browser_click - Click an element
+*/
 function createClickTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.CLICK,
-    description: "Click an element using its ref from a snapshot. Use clickCount: 2 for double-click. Pass waitUntil when the click triggers navigation so the page settles before the next snapshot.",
-    inputSchema: clickInputSchema,
-    execute: async (input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return browser.click(input, threadId);
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.CLICK,
+		description: "Click an element using its ref from a snapshot. Use clickCount: 2 for double-click. Pass waitUntil when the click triggers navigation so the page settles before the next snapshot.",
+		inputSchema: clickInputSchema,
+		execute: async (input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return browser.click(input, threadId);
+		}
+	});
 }
+//#endregion
+//#region src/tools/close.ts
+/**
+* browser_close - Close the browser
+*/
 function createCloseTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.CLOSE,
-    description: "Close the browser. Only use when done with all browsing.",
-    inputSchema: closeInputSchema,
-    execute: async (_input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      if (browser.getScope() !== "shared") {
-        if (!threadId) {
-          throw new Error("browser_close requires agent.threadId when browser scope is not shared");
-        }
-        browser.markBrowserCloseReason("agent", threadId);
-        await browser.closeThreadSession(threadId);
-        return { success: true, hint: "Thread's browser session closed. A new session will be created on next use." };
-      }
-      browser.markBrowserCloseReason("agent");
-      await browser.close();
-      return { success: true, hint: "Browser closed. It will be re-launched automatically on next use." };
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.CLOSE,
+		description: "Close the browser. Only use when done with all browsing.",
+		inputSchema: closeInputSchema,
+		execute: async (_input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			if (browser.getScope() !== "shared") {
+				if (!threadId) throw new Error("browser_close requires agent.threadId when browser scope is not shared");
+				browser.markBrowserCloseReason("agent", threadId);
+				await browser.closeThreadSession(threadId);
+				return {
+					success: true,
+					hint: "Thread's browser session closed. A new session will be created on next use."
+				};
+			}
+			browser.markBrowserCloseReason("agent");
+			await browser.close();
+			return {
+				success: true,
+				hint: "Browser closed. It will be re-launched automatically on next use."
+			};
+		}
+	});
 }
+//#endregion
+//#region src/tools/dialog.ts
+/**
+* browser_dialog - Click element and handle resulting dialog
+*/
 function createDialogTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.DIALOG,
-    description: "Click an element that triggers a browser dialog (alert, confirm, prompt) and handle it. Use this instead of browser_click when you expect a dialog to appear.",
-    inputSchema: dialogInputSchema,
-    execute: async (input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return browser.dialog(input, threadId);
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.DIALOG,
+		description: "Click an element that triggers a browser dialog (alert, confirm, prompt) and handle it. Use this instead of browser_click when you expect a dialog to appear.",
+		inputSchema: dialogInputSchema,
+		execute: async (input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return browser.dialog(input, threadId);
+		}
+	});
 }
+//#endregion
+//#region src/tools/drag.ts
+/**
+* browser_drag - Drag an element to another element
+*/
 function createDragTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.DRAG,
-    description: "Drag an element to another element. Use refs from snapshot when available, or CSS selectors for elements not exposed in the accessibility tree.",
-    inputSchema: dragInputSchema,
-    execute: async (input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return browser.drag(input, threadId);
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.DRAG,
+		description: "Drag an element to another element. Use refs from snapshot when available, or CSS selectors for elements not exposed in the accessibility tree.",
+		inputSchema: dragInputSchema,
+		execute: async (input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return browser.drag(input, threadId);
+		}
+	});
 }
+//#endregion
+//#region src/tools/evaluate.ts
+/**
+* browser_evaluate - Execute JavaScript in the browser
+*/
 function createEvaluateTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.EVALUATE,
-    description: "Execute JavaScript in the browser. Use for complex interactions not covered by other tools. Returns the script result.",
-    inputSchema: evaluateInputSchema,
-    execute: async (input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return browser.evaluate(input, threadId);
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.EVALUATE,
+		description: "Execute JavaScript in the browser. Use for complex interactions not covered by other tools. Returns the script result.",
+		inputSchema: evaluateInputSchema,
+		execute: async (input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return browser.evaluate(input, threadId);
+		}
+	});
 }
+//#endregion
+//#region src/tools/goto.ts
+/**
+* browser_goto - Navigate to a URL
+*/
 function createGotoTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.GOTO,
-    description: "Navigate the browser to a URL.",
-    inputSchema: gotoInputSchema,
-    execute: async (input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return browser.goto(input, threadId);
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.GOTO,
+		description: "Navigate the browser to a URL.",
+		inputSchema: gotoInputSchema,
+		execute: async (input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return browser.goto(input, threadId);
+		}
+	});
 }
+//#endregion
+//#region src/tools/hover.ts
+/**
+* browser_hover - Hover over an element
+*/
 function createHoverTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.HOVER,
-    description: "Hover over an element to trigger hover states (dropdowns, tooltips).",
-    inputSchema: hoverInputSchema,
-    execute: async (input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return browser.hover(input, threadId);
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.HOVER,
+		description: "Hover over an element to trigger hover states (dropdowns, tooltips).",
+		inputSchema: hoverInputSchema,
+		execute: async (input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return browser.hover(input, threadId);
+		}
+	});
 }
+//#endregion
+//#region src/tools/press.ts
+/**
+* browser_press - Press a keyboard key
+*/
 function createPressTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.PRESS,
-    description: "Press a keyboard key (e.g., Enter, Tab, Escape, Control+a). Pass waitUntil when the keypress triggers navigation (e.g., Enter to submit a form) so the page settles before the next snapshot.",
-    inputSchema: pressInputSchema,
-    execute: async (input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return browser.press(input, threadId);
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.PRESS,
+		description: "Press a keyboard key (e.g., Enter, Tab, Escape, Control+a). Pass waitUntil when the keypress triggers navigation (e.g., Enter to submit a form) so the page settles before the next snapshot.",
+		inputSchema: pressInputSchema,
+		execute: async (input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return browser.press(input, threadId);
+		}
+	});
 }
+//#endregion
+//#region src/tools/screenshot.ts
+/**
+* browser_screenshot - Capture a screenshot of the current page
+*/
 function createScreenshotTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.SCREENSHOT,
-    description: "Capture a screenshot of the current viewport as a visible PNG (set fullPage: true for full-page capture). Use snapshot when you only need text or interactive elements \u2014 screenshots are expensive. Use this when you need to visually inspect the page, e.g. evaluating images, product photos, layout, design, or colors.",
-    inputSchema: screenshotInputSchema,
-    execute: async (input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return await browser.screenshot(input, threadId);
-    },
-    toModelOutput(output) {
-      const result = output;
-      if (typeof result.base64 !== "string") {
-        return {
-          type: "content",
-          value: [{ type: "text", text: result.message ?? "Failed to capture screenshot." }]
-        };
-      }
-      return {
-        type: "content",
-        value: [
-          {
-            type: "media",
-            mediaType: "image/png",
-            data: result.base64
-          }
-        ]
-      };
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.SCREENSHOT,
+		description: "Capture a screenshot of the current viewport as a visible PNG (set fullPage: true for full-page capture). Use snapshot when you only need text or interactive elements — screenshots are expensive. Use this when you need to visually inspect the page, e.g. evaluating images, product photos, layout, design, or colors.",
+		inputSchema: screenshotInputSchema,
+		execute: async (input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return await browser.screenshot(input, threadId);
+		},
+		toModelOutput(output) {
+			const result = output;
+			if (typeof result.base64 !== "string") return {
+				type: "content",
+				value: [{
+					type: "text",
+					text: result.message ?? "Failed to capture screenshot."
+				}]
+			};
+			return {
+				type: "content",
+				value: [{
+					type: "media",
+					mediaType: "image/png",
+					data: result.base64
+				}]
+			};
+		}
+	});
 }
+//#endregion
+//#region src/tools/scroll.ts
+/**
+* browser_scroll - Scroll the page or element
+*/
 function createScrollTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.SCROLL,
-    description: "Scroll the page or a specific element.",
-    inputSchema: scrollInputSchema,
-    execute: async (input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return browser.scroll(input, threadId);
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.SCROLL,
+		description: "Scroll the page or a specific element.",
+		inputSchema: scrollInputSchema,
+		execute: async (input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return browser.scroll(input, threadId);
+		}
+	});
 }
+//#endregion
+//#region src/tools/select.ts
+/**
+* browser_select - Select option from dropdown
+*/
 function createSelectTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.SELECT,
-    description: "Select an option from a dropdown by value, label, or index. Pass waitUntil when the selection triggers navigation so the page settles before the next snapshot.",
-    inputSchema: selectInputSchema,
-    execute: async (input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return browser.select(input, threadId);
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.SELECT,
+		description: "Select an option from a dropdown by value, label, or index. Pass waitUntil when the selection triggers navigation so the page settles before the next snapshot.",
+		inputSchema: selectInputSchema,
+		execute: async (input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return browser.select(input, threadId);
+		}
+	});
 }
+//#endregion
+//#region src/tools/snapshot.ts
+/**
+* browser_snapshot - Get accessibility tree snapshot
+*/
 function createSnapshotTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.SNAPSHOT,
-    description: "Get accessibility tree snapshot of the page. Returns text-based representation with element refs like [ref=e1], [ref=e2] for targeting.",
-    inputSchema: snapshotInputSchema,
-    execute: async (input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return browser.snapshot(input, threadId);
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.SNAPSHOT,
+		description: "Get accessibility tree snapshot of the page. Returns text-based representation with element refs like [ref=e1], [ref=e2] for targeting.",
+		inputSchema: snapshotInputSchema,
+		execute: async (input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return browser.snapshot(input, threadId);
+		}
+	});
 }
+//#endregion
+//#region src/tools/tabs.ts
+/**
+* browser_tabs - Manage browser tabs
+*/
 function createTabsTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.TABS,
-    description: "Manage browser tabs: list, open new, switch, or close tabs.",
-    inputSchema: tabsInputSchema,
-    execute: async (input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return browser.tabs(input, threadId);
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.TABS,
+		description: "Manage browser tabs: list, open new, switch, or close tabs.",
+		inputSchema: tabsInputSchema,
+		execute: async (input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return browser.tabs(input, threadId);
+		}
+	});
 }
+//#endregion
+//#region src/tools/type.ts
+/**
+* browser_type - Type text into an element
+*/
 function createTypeTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.TYPE,
-    description: "Type text into an input element. Use clear: true to replace existing content.",
-    inputSchema: typeInputSchema,
-    execute: async (input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return browser.type(input, threadId);
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.TYPE,
+		description: "Type text into an input element. Use clear: true to replace existing content.",
+		inputSchema: typeInputSchema,
+		execute: async (input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return browser.type(input, threadId);
+		}
+	});
 }
+//#endregion
+//#region src/tools/wait.ts
+/**
+* browser_wait - Wait for an element or condition
+*/
 function createWaitTool(browser) {
-  return createTool({
-    id: BROWSER_TOOLS.WAIT,
-    description: "Wait for an element to appear, disappear, or reach a state.",
-    inputSchema: waitInputSchema,
-    execute: async (input, { agent }) => {
-      const threadId = agent?.threadId;
-      browser.setCurrentThread(threadId);
-      await browser.ensureReady();
-      return browser.wait(input, threadId);
-    }
-  });
+	return createTool({
+		id: BROWSER_TOOLS.WAIT,
+		description: "Wait for an element to appear, disappear, or reach a state.",
+		inputSchema: waitInputSchema,
+		execute: async (input, { agent }) => {
+			const threadId = agent?.threadId;
+			browser.setCurrentThread(threadId);
+			await browser.ensureReady();
+			return browser.wait(input, threadId);
+		}
+	});
 }
-
-// src/tools/index.ts
+//#endregion
+//#region src/tools/index.ts
+/**
+* Creates all browser tools bound to an AgentBrowser instance.
+* The browser is lazily initialized on first tool use.
+*/
 function createAgentBrowserTools(browser) {
-  return {
-    // Core (9)
-    [BROWSER_TOOLS.GOTO]: createGotoTool(browser),
-    [BROWSER_TOOLS.SNAPSHOT]: createSnapshotTool(browser),
-    [BROWSER_TOOLS.CLICK]: createClickTool(browser),
-    [BROWSER_TOOLS.TYPE]: createTypeTool(browser),
-    [BROWSER_TOOLS.PRESS]: createPressTool(browser),
-    [BROWSER_TOOLS.SELECT]: createSelectTool(browser),
-    [BROWSER_TOOLS.SCROLL]: createScrollTool(browser),
-    [BROWSER_TOOLS.CLOSE]: createCloseTool(browser),
-    // Utility
-    [BROWSER_TOOLS.SCREENSHOT]: createScreenshotTool(browser),
-    // Extended
-    [BROWSER_TOOLS.HOVER]: createHoverTool(browser),
-    [BROWSER_TOOLS.BACK]: createBackTool(browser),
-    [BROWSER_TOOLS.DIALOG]: createDialogTool(browser),
-    [BROWSER_TOOLS.WAIT]: createWaitTool(browser),
-    [BROWSER_TOOLS.TABS]: createTabsTool(browser),
-    [BROWSER_TOOLS.DRAG]: createDragTool(browser),
-    // Escape hatch (1)
-    [BROWSER_TOOLS.EVALUATE]: createEvaluateTool(browser)
-  };
+	return {
+		[BROWSER_TOOLS.GOTO]: createGotoTool(browser),
+		[BROWSER_TOOLS.SNAPSHOT]: createSnapshotTool(browser),
+		[BROWSER_TOOLS.CLICK]: createClickTool(browser),
+		[BROWSER_TOOLS.TYPE]: createTypeTool(browser),
+		[BROWSER_TOOLS.PRESS]: createPressTool(browser),
+		[BROWSER_TOOLS.SELECT]: createSelectTool(browser),
+		[BROWSER_TOOLS.SCROLL]: createScrollTool(browser),
+		[BROWSER_TOOLS.CLOSE]: createCloseTool(browser),
+		[BROWSER_TOOLS.SCREENSHOT]: createScreenshotTool(browser),
+		[BROWSER_TOOLS.HOVER]: createHoverTool(browser),
+		[BROWSER_TOOLS.BACK]: createBackTool(browser),
+		[BROWSER_TOOLS.DIALOG]: createDialogTool(browser),
+		[BROWSER_TOOLS.WAIT]: createWaitTool(browser),
+		[BROWSER_TOOLS.TABS]: createTabsTool(browser),
+		[BROWSER_TOOLS.DRAG]: createDragTool(browser),
+		[BROWSER_TOOLS.EVALUATE]: createEvaluateTool(browser)
+	};
 }
-
-// src/utils.ts
+//#endregion
+//#region src/utils.ts
+/**
+* Get the browser process PID from a BrowserManager instance via CDP.
+*
+* Playwright doesn't expose the browser process PID directly, so we use CDP's
+* SystemInfo.getProcessInfo to get it. This works for both regular browser
+* launches and persistent contexts (profiles).
+*
+* Returns undefined if the PID can't be retrieved (e.g., browser not running).
+*/
 async function getBrowserPid(manager) {
-  try {
-    let browser = manager.getBrowser();
-    if (!browser) {
-      const ctx = manager.getContext();
-      browser = ctx?.browser?.() ?? null;
-    }
-    if (!browser) return void 0;
-    const cdp = await browser.newBrowserCDPSession();
-    try {
-      const info = await cdp.send("SystemInfo.getProcessInfo");
-      const browserProcess = info.processInfo?.find((p) => p.type === "browser");
-      return browserProcess?.id;
-    } finally {
-      await cdp.detach().catch(() => void 0);
-    }
-  } catch {
-    return void 0;
-  }
+	try {
+		let browser = manager.getBrowser();
+		if (!browser) browser = manager.getContext()?.browser?.() ?? null;
+		if (!browser) return void 0;
+		const cdp = await browser.newBrowserCDPSession();
+		try {
+			return ((await cdp.send("SystemInfo.getProcessInfo")).processInfo?.find((p) => p.type === "browser"))?.id;
+		} finally {
+			await cdp.detach().catch(() => void 0);
+		}
+	} catch {
+		return;
+	}
 }
-
-// src/agent-browser.ts
+//#endregion
+//#region src/agent-browser.ts
+/**
+* AgentBrowser - Browser automation using agent-browser (vercel-labs/agent-browser)
+*
+* Uses snapshot + refs pattern for LLM-friendly element targeting.
+*/
 var AgentBrowser = class extends MastraBrowser {
-  id;
-  name = "AgentBrowser";
-  provider = "vercel-labs/agent-browser";
-  defaultTimeout = 3e4;
-  /** Pending PID lookups — awaited in disconnect handlers to avoid racing. */
-  pidLookups = /* @__PURE__ */ new Set();
-  pendingCloseReasons = /* @__PURE__ */ new Map();
-  activeUrlChangeSources = /* @__PURE__ */ new Map();
-  browserConfig;
-  constructor(config = {}) {
-    super(config);
-    this.browserConfig = config;
-    this.id = `agent-browser-${Date.now()}`;
-    if (config.timeout) {
-      this.defaultTimeout = config.timeout;
-    }
-    const effectiveScope = config.cdpUrl ? config.scope ?? "shared" : config.scope ?? "thread";
-    const threadManagerConfig = {
-      scope: effectiveScope,
-      browserConfig: { ...config, headless: this.headless },
-      resolveCdpUrl: this.resolveCdpUrl.bind(this),
-      logger: this.logger,
-      // When a new thread session is created, notify listeners so screencast can start
-      onSessionCreated: (session) => {
-        this.notifyBrowserReady(session.threadId);
-      },
-      // When a new browser is created for a thread, set up close listener
-      onBrowserCreated: (manager, threadId) => {
-        this.setupCloseListenerForThread(manager, threadId);
-      }
-    };
-    const createTm = config.createThreadManager ?? ((opts) => new AgentBrowserThreadManager(opts));
-    this.threadManager = createTm(threadManagerConfig);
-  }
-  // ---------------------------------------------------------------------------
-  // Thread Scope (delegated to ThreadManager)
-  // ---------------------------------------------------------------------------
-  /**
-   * Ensure browser is ready and thread session exists.
-   * Creates a new page/context for the current thread if needed.
-   *
-   * For 'thread' scope, we need to create the thread session BEFORE
-   * calling super.ensureReady() because the base class's ensureReady() will
-   * call checkBrowserAlive(), which needs at least one thread browser to exist.
-   */
-  async ensureReady() {
-    const scope = this.threadManager.getScope();
-    const threadId = this.getCurrentThread();
-    const existingSession = this.threadManager.hasSession(threadId);
-    if (scope === "thread" && !existingSession) {
-      await this.getManagerForThread(threadId);
-    }
-    await super.ensureReady();
-    if (scope === "thread" && existingSession) {
-      await this.getManagerForThread(threadId);
-    }
-  }
-  /**
-   * Get the browser manager for the current thread.
-   * Delegates to ThreadManager for scope handling.
-   */
-  async getManagerForThread(threadId) {
-    const effectiveThreadId = threadId ?? this.getCurrentThread();
-    const scope = this.threadManager.getScope();
-    if (scope === "thread" && (!effectiveThreadId || effectiveThreadId === DEFAULT_THREAD_ID)) {
-      const existingManager = this.threadManager.getExistingManagerForThread(effectiveThreadId);
-      if (existingManager) {
-        return existingManager;
-      }
-    }
-    return this.threadManager.getManagerForThread(effectiveThreadId);
-  }
-  // ---------------------------------------------------------------------------
-  // Lifecycle
-  // ---------------------------------------------------------------------------
-  async doLaunch() {
-    this.pendingCloseReasons.clear();
-    this.activeUrlChangeSources.clear();
-    const scope = this.threadManager.getScope();
-    if (scope === "thread") {
-      this.sharedManager = new BrowserManager();
-      this.threadManager.setSharedManager(this.sharedManager);
-      return;
-    }
-    this.sharedManager = new BrowserManager();
-    const localConfig = this.config;
-    const launchOptions = {
-      headless: this.headless,
-      viewport: localConfig.viewport,
-      profile: localConfig.profile,
-      executablePath: localConfig.executablePath,
-      storageState: localConfig.storageState
-    };
-    if (localConfig.cdpUrl) {
-      launchOptions.cdpUrl = await this.resolveCdpUrl(localConfig.cdpUrl);
-    }
-    await this.sharedManager.launch(launchOptions);
-    this.threadManager.setSharedManager(this.sharedManager);
-    this.setupCloseListenerForSharedScope(this.sharedManager);
-  }
-  /**
-   * Set up close event listeners for 'shared' scope browser.
-   * This handles the case where the shared browser is closed externally.
-   */
-  setupCloseListenerForSharedScope(manager) {
-    try {
-      const pidLookup = getBrowserPid(manager).then((pid) => {
-        if (pid && this.sharedManager === manager) this.sharedBrowserPid = pid;
-      }).finally(() => this.pidLookups.delete(pidLookup));
-      this.pidLookups.add(pidLookup);
-      let disconnectHandled = false;
-      const handleDisconnect = () => {
-        if (disconnectHandled) return;
-        disconnectHandled = true;
-        this.rememberClosedBrowserState(manager, "user");
-        void pidLookup.catch(() => void 0).then(() => this.handleBrowserDisconnected());
-      };
-      const context = manager.getContext();
-      if (context) {
-        context.on("close", handleDisconnect);
-      }
-      const pages = manager.getPages();
-      for (const page of pages) {
-        page.on("close", () => {
-          const remainingPages = manager.getPages();
-          if (remainingPages.length === 0) {
-            handleDisconnect();
-          }
-        });
-      }
-    } catch {
-    }
-  }
-  async doClose() {
-    await Promise.allSettled([...this.pidLookups]);
-    this.pidLookups.clear();
-    await this.threadManager.destroyAllSessions();
-    this.setCurrentThread(void 0);
-    const scope = this.threadManager.getScope();
-    if (scope === "shared" && this.sharedManager) {
-      await this.sharedManager.close();
-    }
-    this.sharedManager = null;
-  }
-  async closeThreadSession(threadId) {
-    const manager = this.threadManager.getExistingManagerForThread(threadId);
-    if (manager) {
-      const state = this.getBrowserStateForManager(manager, threadId);
-      if (state) this.threadManager.updateBrowserState(threadId, state);
-    }
-    await super.closeThreadSession(threadId);
-  }
-  /**
-   * Check if the browser is still alive by verifying the page is connected.
-   * Called by base class ensureReady() to detect externally closed browsers.
-   */
-  async checkBrowserAlive() {
-    const scope = this.threadManager.getScope();
-    if (scope === "thread") {
-      return this.threadManager.hasActiveThreadManagers();
-    }
-    if (!this.sharedManager) {
-      return false;
-    }
-    try {
-      const page = this.sharedManager.getPage();
-      const url = page.url();
-      if (url && url !== "about:blank") {
-        const state = await this.getBrowserState();
-        if (state) {
-          this.lastBrowserState = state;
-        }
-      }
-      return true;
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      if (this.isDisconnectionError(msg)) {
-        this.logger.debug?.("Browser was externally closed");
-      }
-      return false;
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // Tools
-  // ---------------------------------------------------------------------------
-  /**
-   * Get the browser tools for this provider.
-   * Returns 16 flat tools for browser automation.
-   */
-  getTools() {
-    const tools = createAgentBrowserTools(this);
-    if (this.browserConfig.recording) {
-      Object.assign(tools, createBrowserRecordingTools(this, this.browserConfig.recording));
-    }
-    const exclude = this.browserConfig.excludeTools;
-    if (exclude?.length) {
-      for (const name of exclude) {
-        delete tools[name];
-      }
-    }
-    return tools;
-  }
-  // ---------------------------------------------------------------------------
-  // Helpers
-  // ---------------------------------------------------------------------------
-  browserStateKey(threadId) {
-    return threadId ?? this.getCurrentThread() ?? DEFAULT_THREAD_ID;
-  }
-  markBrowserCloseReason(reason, threadId) {
-    this.pendingCloseReasons.set(this.browserStateKey(threadId), reason);
-  }
-  markActiveUrlChangeSource(source, url, threadId) {
-    this.activeUrlChangeSources.set(this.browserStateKey(threadId), { url, source });
-  }
-  getCloseReason(threadId) {
-    return this.pendingCloseReasons.get(this.browserStateKey(threadId)) ?? this.pendingCloseReasons.get(DEFAULT_THREAD_ID);
-  }
-  getActiveUrlChangeSource(activeUrl, threadId) {
-    const entry = this.activeUrlChangeSources.get(this.browserStateKey(threadId));
-    return entry && entry.url === activeUrl ? entry.source : void 0;
-  }
-  rememberClosedBrowserState(manager, reason, threadId) {
-    const state = this.getBrowserStateForManager(manager, threadId);
-    if (!state || state.tabs.length === 0) return;
-    const closedState = { ...state, closeReason: this.getCloseReason(threadId) ?? reason };
-    if (threadId) {
-      this.threadManager.updateBrowserState(threadId, closedState);
-    } else {
-      this.lastBrowserState = closedState;
-    }
-  }
-  /**
-   * Get the page for the current thread.
-   * Uses thread scope if enabled, otherwise returns the shared page.
-   * @param explicitThreadId - Optional thread ID to use instead of getCurrentThread()
-   *                           Use this to avoid race conditions in concurrent tool calls.
-   */
-  async getPage(explicitThreadId) {
-    const scope = this.getScope();
-    const threadId = explicitThreadId ?? this.getCurrentThread();
-    if (scope === "thread") {
-      return this.threadManager.getPageForThread(threadId);
-    }
-    if (!this.sharedManager) throw new Error("Browser not launched");
-    return this.sharedManager.getPage();
-  }
-  /**
-   * Get the active page for a thread (implements abstract method from base class).
-   * Returns null if no page is available, unlike getPage which throws.
-   */
-  async getActivePage(threadId) {
-    try {
-      return await this.getPage(threadId);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Set up close event listener for a thread's browser manager.
-   * This handles the case where a thread's browser is closed externally.
-   */
-  setupCloseListenerForThread(manager, threadId) {
-    try {
-      const pidLookup = getBrowserPid(manager).then((pid) => {
-        if (pid && this.threadManager?.getExistingManagerForThread(threadId) === manager) {
-          this.threadBrowserPids.set(threadId, pid);
-        }
-      }).finally(() => this.pidLookups.delete(pidLookup));
-      this.pidLookups.add(pidLookup);
-      let disconnectHandled = false;
-      const handleDisconnect = () => {
-        if (disconnectHandled) return;
-        disconnectHandled = true;
-        this.rememberClosedBrowserState(manager, "user", threadId);
-        void pidLookup.catch(() => void 0).then(() => this.handleThreadBrowserDisconnected(threadId));
-      };
-      const context = manager.getContext();
-      if (context) {
-        context.on("close", handleDisconnect);
-      }
-      const pages = manager.getPages();
-      for (const page of pages) {
-        page.on("close", () => {
-          const remainingPages = manager.getPages();
-          if (remainingPages.length === 0) {
-            handleDisconnect();
-          }
-        });
-      }
-    } catch {
-    }
-  }
-  /**
-   * Create an error response from an exception.
-   * Extends base class to add agent-browser specific error handling.
-   */
-  createErrorFromException(error, context) {
-    const msg = error instanceof Error ? error.message : String(error);
-    if (msg.includes("stale") || msg.includes("Stale")) {
-      return this.createError(
-        "stale_ref",
-        "Element ref is no longer valid.",
-        "Get a fresh snapshot and use updated refs."
-      );
-    }
-    if (msg.includes("not found") || msg.includes("No element")) {
-      return this.createError(
-        "element_not_found",
-        "Element not found.",
-        "Check the ref is correct or get a fresh snapshot."
-      );
-    }
-    return super.createErrorFromException(error, context);
-  }
-  async requireLocator(ref, threadId) {
-    const manager = await this.getManagerForThread(threadId);
-    return manager.getLocatorFromRef(ref);
-  }
-  async getScrollInfo(threadId) {
-    const page = await this.getPage(threadId);
-    const info = await page.evaluate(`({
+	id;
+	name = "AgentBrowser";
+	provider = "vercel-labs/agent-browser";
+	defaultTimeout = 3e4;
+	/** Pending PID lookups — awaited in disconnect handlers to avoid racing. */
+	pidLookups = /* @__PURE__ */ new Set();
+	pendingCloseReasons = /* @__PURE__ */ new Map();
+	activeUrlChangeSources = /* @__PURE__ */ new Map();
+	browserConfig;
+	constructor(config = {}) {
+		super(config);
+		this.browserConfig = config;
+		this.id = `agent-browser-${Date.now()}`;
+		if (config.timeout) this.defaultTimeout = config.timeout;
+		const threadManagerConfig = {
+			scope: config.cdpUrl ? config.scope ?? "shared" : config.scope ?? "thread",
+			browserConfig: {
+				...config,
+				headless: this.headless
+			},
+			resolveCdpUrl: this.resolveCdpUrl.bind(this),
+			logger: this.logger,
+			onSessionCreated: (session) => {
+				this.notifyBrowserReady(session.threadId);
+			},
+			onBrowserCreated: (manager, threadId) => {
+				this.setupCloseListenerForThread(manager, threadId);
+			}
+		};
+		const createTm = config.createThreadManager ?? ((opts) => new AgentBrowserThreadManager(opts));
+		this.threadManager = createTm(threadManagerConfig);
+	}
+	/**
+	* Ensure browser is ready and thread session exists.
+	* Creates a new page/context for the current thread if needed.
+	*
+	* For 'thread' scope, we need to create the thread session BEFORE
+	* calling super.ensureReady() because the base class's ensureReady() will
+	* call checkBrowserAlive(), which needs at least one thread browser to exist.
+	*/
+	async ensureReady() {
+		const scope = this.threadManager.getScope();
+		const threadId = this.getCurrentThread();
+		const existingSession = this.threadManager.hasSession(threadId);
+		if (scope === "thread" && !existingSession) await this.getManagerForThread(threadId);
+		await super.ensureReady();
+		if (scope === "thread" && existingSession) await this.getManagerForThread(threadId);
+	}
+	/**
+	* Get the browser manager for the current thread.
+	* Delegates to ThreadManager for scope handling.
+	*/
+	async getManagerForThread(threadId) {
+		const effectiveThreadId = threadId ?? this.getCurrentThread();
+		if (this.threadManager.getScope() === "thread" && (!effectiveThreadId || effectiveThreadId === DEFAULT_THREAD_ID)) {
+			const existingManager = this.threadManager.getExistingManagerForThread(effectiveThreadId);
+			if (existingManager) return existingManager;
+		}
+		return this.threadManager.getManagerForThread(effectiveThreadId);
+	}
+	async doLaunch() {
+		this.pendingCloseReasons.clear();
+		this.activeUrlChangeSources.clear();
+		if (this.threadManager.getScope() === "thread") {
+			this.sharedManager = new BrowserManager();
+			this.threadManager.setSharedManager(this.sharedManager);
+			return;
+		}
+		this.sharedManager = new BrowserManager();
+		const localConfig = this.config;
+		const launchOptions = {
+			headless: this.headless,
+			viewport: localConfig.viewport,
+			profile: localConfig.profile,
+			executablePath: localConfig.executablePath,
+			storageState: localConfig.storageState
+		};
+		if (localConfig.cdpUrl) launchOptions.cdpUrl = await this.resolveCdpUrl(localConfig.cdpUrl);
+		if (localConfig.cdpHeaders) launchOptions.cdpHeaders = localConfig.cdpHeaders;
+		await this.sharedManager.launch(launchOptions);
+		this.threadManager.setSharedManager(this.sharedManager);
+		this.setupCloseListenerForSharedScope(this.sharedManager);
+	}
+	/**
+	* Set up close event listeners for 'shared' scope browser.
+	* This handles the case where the shared browser is closed externally.
+	*/
+	setupCloseListenerForSharedScope(manager) {
+		try {
+			const pidLookup = getBrowserPid(manager).then((pid) => {
+				if (pid && this.sharedManager === manager) this.sharedBrowserPid = pid;
+			}).finally(() => this.pidLookups.delete(pidLookup));
+			this.pidLookups.add(pidLookup);
+			let disconnectHandled = false;
+			const handleDisconnect = () => {
+				if (disconnectHandled) return;
+				disconnectHandled = true;
+				this.rememberClosedBrowserState(manager, "user");
+				pidLookup.catch(() => void 0).then(() => this.handleBrowserDisconnected());
+			};
+			const context = manager.getContext();
+			if (context) context.on("close", handleDisconnect);
+			const pages = manager.getPages();
+			for (const page of pages) page.on("close", () => {
+				if (manager.getPages().length === 0) handleDisconnect();
+			});
+		} catch {}
+	}
+	async doClose() {
+		await Promise.allSettled([...this.pidLookups]);
+		this.pidLookups.clear();
+		await this.threadManager.destroyAllSessions();
+		this.setCurrentThread(void 0);
+		if (this.threadManager.getScope() === "shared" && this.sharedManager) await this.sharedManager.close();
+		this.sharedManager = null;
+	}
+	async closeThreadSession(threadId) {
+		const manager = this.threadManager.getExistingManagerForThread(threadId);
+		if (manager) {
+			const state = this.getBrowserStateForManager(manager, threadId);
+			if (state) this.threadManager.updateBrowserState(threadId, state);
+		}
+		await super.closeThreadSession(threadId);
+	}
+	/**
+	* Check if the browser is still alive by verifying the page is connected.
+	* Called by base class ensureReady() to detect externally closed browsers.
+	*/
+	async checkBrowserAlive() {
+		if (this.threadManager.getScope() === "thread") return this.threadManager.hasActiveThreadManagers();
+		if (!this.sharedManager) return false;
+		try {
+			const url = this.sharedManager.getPage().url();
+			if (url && url !== "about:blank") {
+				const state = await this.getBrowserState();
+				if (state) this.lastBrowserState = state;
+			}
+			return true;
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			if (this.isDisconnectionError(msg)) this.logger.debug?.("Browser was externally closed");
+			return false;
+		}
+	}
+	/**
+	* Get the browser tools for this provider.
+	* Returns 16 flat tools for browser automation.
+	*/
+	getTools() {
+		const tools = createAgentBrowserTools(this);
+		if (this.browserConfig.recording) Object.assign(tools, createBrowserRecordingTools(this, this.browserConfig.recording));
+		const exclude = this.browserConfig.excludeTools;
+		if (exclude?.length) for (const name of exclude) delete tools[name];
+		return tools;
+	}
+	browserStateKey(threadId) {
+		return threadId ?? this.getCurrentThread() ?? DEFAULT_THREAD_ID;
+	}
+	markBrowserCloseReason(reason, threadId) {
+		this.pendingCloseReasons.set(this.browserStateKey(threadId), reason);
+	}
+	markActiveUrlChangeSource(source, url, threadId) {
+		this.activeUrlChangeSources.set(this.browserStateKey(threadId), {
+			url,
+			source
+		});
+	}
+	getCloseReason(threadId) {
+		return this.pendingCloseReasons.get(this.browserStateKey(threadId)) ?? this.pendingCloseReasons.get(DEFAULT_THREAD_ID);
+	}
+	getActiveUrlChangeSource(activeUrl, threadId) {
+		const entry = this.activeUrlChangeSources.get(this.browserStateKey(threadId));
+		return entry && entry.url === activeUrl ? entry.source : void 0;
+	}
+	rememberClosedBrowserState(manager, reason, threadId) {
+		const state = this.getBrowserStateForManager(manager, threadId);
+		if (!state || state.tabs.length === 0) return;
+		const closedState = {
+			...state,
+			closeReason: this.getCloseReason(threadId) ?? reason
+		};
+		if (threadId) this.threadManager.updateBrowserState(threadId, closedState);
+		else this.lastBrowserState = closedState;
+	}
+	/**
+	* Get the page for the current thread.
+	* Uses thread scope if enabled, otherwise returns the shared page.
+	* @param explicitThreadId - Optional thread ID to use instead of getCurrentThread()
+	*                           Use this to avoid race conditions in concurrent tool calls.
+	*/
+	async getPage(explicitThreadId) {
+		const scope = this.getScope();
+		const threadId = explicitThreadId ?? this.getCurrentThread();
+		if (scope === "thread") return this.threadManager.getPageForThread(threadId);
+		if (!this.sharedManager) throw new Error("Browser not launched");
+		return this.sharedManager.getPage();
+	}
+	/**
+	* Get the active page for a thread (implements abstract method from base class).
+	* Returns null if no page is available, unlike getPage which throws.
+	*/
+	async getActivePage(threadId) {
+		try {
+			return await this.getPage(threadId);
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Set up close event listener for a thread's browser manager.
+	* This handles the case where a thread's browser is closed externally.
+	*/
+	setupCloseListenerForThread(manager, threadId) {
+		try {
+			const pidLookup = getBrowserPid(manager).then((pid) => {
+				if (pid && this.threadManager?.getExistingManagerForThread(threadId) === manager) this.threadBrowserPids.set(threadId, pid);
+			}).finally(() => this.pidLookups.delete(pidLookup));
+			this.pidLookups.add(pidLookup);
+			let disconnectHandled = false;
+			const handleDisconnect = () => {
+				if (disconnectHandled) return;
+				disconnectHandled = true;
+				this.rememberClosedBrowserState(manager, "user", threadId);
+				pidLookup.catch(() => void 0).then(() => this.handleThreadBrowserDisconnected(threadId));
+			};
+			const context = manager.getContext();
+			if (context) context.on("close", handleDisconnect);
+			const pages = manager.getPages();
+			for (const page of pages) page.on("close", () => {
+				if (manager.getPages().length === 0) handleDisconnect();
+			});
+		} catch {}
+	}
+	/**
+	* Create an error response from an exception.
+	* Extends base class to add agent-browser specific error handling.
+	*/
+	createErrorFromException(error, context) {
+		const msg = error instanceof Error ? error.message : String(error);
+		if (msg.includes("stale") || msg.includes("Stale")) return this.createError("stale_ref", "Element ref is no longer valid.", "Get a fresh snapshot and use updated refs.");
+		if (msg.includes("not found") || msg.includes("No element")) return this.createError("element_not_found", "Element not found.", "Check the ref is correct or get a fresh snapshot.");
+		return super.createErrorFromException(error, context);
+	}
+	async requireLocator(ref, threadId) {
+		return (await this.getManagerForThread(threadId)).getLocatorFromRef(ref);
+	}
+	async getScrollInfo(threadId) {
+		const info = await (await this.getPage(threadId)).evaluate(`({
       scrollY: Math.round(window.scrollY),
       scrollHeight: document.documentElement.scrollHeight,
       viewportHeight: window.innerHeight
     })`);
-    if (!info || typeof info.scrollHeight !== "number") {
-      return {
-        scrollY: 0,
-        scrollHeight: 0,
-        viewportHeight: 0,
-        atTop: true,
-        atBottom: true,
-        percentDown: 0
-      };
-    }
-    const maxScroll = info.scrollHeight - info.viewportHeight;
-    return {
-      ...info,
-      atTop: info.scrollY < 50,
-      atBottom: info.scrollY >= maxScroll - 50,
-      percentDown: maxScroll > 0 ? Math.round(info.scrollY / maxScroll * 100) : 0
-    };
-  }
-  // ---------------------------------------------------------------------------
-  // URL Access
-  // ---------------------------------------------------------------------------
-  /**
-   * Get the current page URL without launching the browser.
-   * @param threadId - Optional thread ID for thread-isolated browsers
-   * @returns The current URL string, or null if browser is not running
-   */
-  async getCurrentUrl(threadId) {
-    if (!this.isBrowserRunning()) {
-      return null;
-    }
-    try {
-      const effectiveThreadId = threadId ?? this.getCurrentThread();
-      const scope = this.threadManager.getScope();
-      if (scope === "thread" && effectiveThreadId) {
-        const manager2 = this.threadManager.getExistingManagerForThread(effectiveThreadId);
-        if (!manager2) {
-          return null;
-        }
-        const url2 = manager2.getPage().url();
-        if (url2 && url2 !== "about:blank") {
-          const state = this.getBrowserStateForManager(manager2);
-          if (state) {
-            this.threadManager.updateBrowserState(effectiveThreadId, state);
-          }
-        }
-        return url2;
-      }
-      const manager = await this.getManagerForThread(threadId);
-      const url = manager.getPage().url();
-      if (url && url !== "about:blank") {
-        const state = this.getBrowserStateForManager(manager);
-        if (state) {
-          this.lastBrowserState = state;
-        }
-      }
-      return url;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Navigate to a URL (simple form). Used internally for restoring state on relaunch.
-   */
-  async navigateTo(url) {
-    if (!this.isBrowserRunning()) {
-      return;
-    }
-    try {
-      const page = await this.getPage();
-      await page.goto(url, {
-        timeout: this.defaultTimeout,
-        waitUntil: "domcontentloaded"
-      });
-    } catch {
-    }
-  }
-  /**
-   * Get the current browser state (all tabs and active tab index).
-   */
-  async getBrowserState(threadId) {
-    if (!this.isBrowserRunning(threadId)) {
-      return null;
-    }
-    try {
-      const manager = await this.getManagerForThread(threadId);
-      return this.getBrowserStateForManager(manager, threadId);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Get browser state for a thread (implements abstract method from base class).
-   * Sync version that uses existing manager lookup without creating sessions.
-   */
-  getBrowserStateForThread(threadId) {
-    const effectiveThreadId = threadId ?? this.getCurrentThread() ?? DEFAULT_THREAD_ID;
-    const manager = this.threadManager.getExistingManagerForThread(effectiveThreadId);
-    if (!manager) return null;
-    return this.getBrowserStateForManager(manager, effectiveThreadId);
-  }
-  /**
-   * Get browser state from a specific manager instance.
-   */
-  getBrowserStateForManager(manager, threadId) {
-    try {
-      const stateKey = this.browserStateKey(threadId);
-      const pages = manager.getPages();
-      const activeIndex = manager.getActiveIndex();
-      const tabs = pages.map((page) => ({
-        url: page.url()
-      }));
-      const activeUrl = tabs[activeIndex]?.url;
-      const previousState = this.threadManager.getSavedBrowserState(stateKey) ?? this.lastBrowserState;
-      const previousUrl = previousState?.tabs[previousState.activeTabIndex]?.url;
-      const activeUrlChangeSource = this.getActiveUrlChangeSource(activeUrl, stateKey) ?? (previousUrl && activeUrl !== previousUrl ? "user" : void 0);
-      const state = {
-        tabs,
-        activeTabIndex: activeIndex,
-        ...this.getCloseReason(stateKey) ? { closeReason: this.getCloseReason(stateKey) } : {},
-        ...activeUrlChangeSource ? { activeUrlChangeSource } : {}
-      };
-      this.threadManager.updateBrowserState(stateKey, state);
-      this.lastBrowserState = state;
-      return state;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Get all open tabs with their URLs and titles.
-   */
-  async getTabState(threadId) {
-    const state = await this.getBrowserState(threadId);
-    return state?.tabs ?? [];
-  }
-  /**
-   * Get the active tab index.
-   */
-  async getActiveTabIndex(threadId) {
-    if (!this.isBrowserRunning()) {
-      return 0;
-    }
-    try {
-      const manager = await this.getManagerForThread(threadId);
-      return manager.getActiveIndex();
-    } catch {
-      return 0;
-    }
-  }
-  /**
-   * Export the current browser session's storage state (cookies, localStorage) to a JSON file.
-   * This can later be loaded via the `storageState` config option to restore the session.
-   *
-   * @param path - File path to save the storage state JSON
-   * @param threadId - Optional thread ID (defaults to current thread)
-   */
-  async exportStorageState(path, threadId) {
-    const effectiveThreadId = threadId ?? this.getCurrentThread();
-    const manager = this.threadManager.getExistingManagerForThread(effectiveThreadId);
-    if (!manager) {
-      throw new Error("No browser is running. Launch a browser first before exporting storage state.");
-    }
-    const context = manager.getContext();
-    if (!context) {
-      throw new Error("Browser context not available");
-    }
-    await context.storageState({ path });
-  }
-  // ---------------------------------------------------------------------------
-  // 1. browser_goto - Navigate to URL
-  // ---------------------------------------------------------------------------
-  async goto(input, threadId) {
-    try {
-      const page = await this.getPage(threadId);
-      await page.goto(input.url, {
-        timeout: input.timeout ?? this.defaultTimeout,
-        waitUntil: input.waitUntil ?? "domcontentloaded"
-      });
-      const url = page.url();
-      this.markActiveUrlChangeSource("agent", url, threadId);
-      return {
-        success: true,
-        url,
-        title: await page.title(),
-        hint: "Take a snapshot to see interactive elements and get refs."
-      };
-    } catch (error) {
-      return this.createErrorFromException(error, "Goto");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // 2. browser_snapshot - Capture accessibility tree
-  // ---------------------------------------------------------------------------
-  async snapshot(input, threadId) {
-    try {
-      const manager = await this.getManagerForThread(threadId);
-      const page = await this.getPage(threadId);
-      const rawSnapshot = await manager.getSnapshot({
-        interactive: input.interactiveOnly ?? true,
-        compact: true
-      });
-      const snapshot = (rawSnapshot.tree ?? "").replace(/\[ref=(\w+)\]/g, "@$1");
-      const scrollInfo = await this.getScrollInfo(threadId);
-      let scrollText;
-      if (scrollInfo.atTop && !scrollInfo.atBottom) {
-        scrollText = "TOP - more content below";
-      } else if (scrollInfo.atBottom) {
-        scrollText = "BOTTOM of page";
-      } else {
-        scrollText = `${scrollInfo.percentDown}% down`;
-      }
-      const refs = snapshot.match(/@e\d+/g) || [];
-      const elementCount = new Set(refs).size;
-      return {
-        success: true,
-        snapshot,
-        url: page.url(),
-        title: await page.title(),
-        elementCount,
-        scroll: scrollText,
-        hint: elementCount === 0 ? "No interactive elements found. Try scrolling or setting interactiveOnly:false." : void 0
-      };
-    } catch (error) {
-      return this.createErrorFromException(error, "Snapshot");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // browser_screenshot - Capture a screenshot of the current page
-  // ---------------------------------------------------------------------------
-  async screenshot(input, threadId) {
-    try {
-      const page = await this.getPage(threadId);
-      const buffer = await page.screenshot({
-        fullPage: input.fullPage ?? false,
-        type: "png"
-      });
-      const base64 = Buffer.from(buffer).toString("base64");
-      return {
-        base64,
-        url: page.url(),
-        title: await page.title()
-      };
-    } catch (error) {
-      return this.createErrorFromException(error, "Screenshot");
-    }
-  }
-  /**
-   * Start a `waitForNavigation` wait (when `waitUntil` is set) and immediately
-   * attach a noop catch handler so a navigation timeout/rejection can't become
-   * an unhandled rejection (crashing the process) while the caller's action is
-   * still pending. Callers should still `await` the returned promise to observe
-   * the original error.
-   */
-  startNavigationWait(page, waitUntil, timeout) {
-    const navigation = waitUntil ? page.waitForNavigation({ waitUntil, timeout }) : void 0;
-    navigation?.catch(() => {
-    });
-    return navigation;
-  }
-  // ---------------------------------------------------------------------------
-  // 3. browser_click - Click on element
-  // ---------------------------------------------------------------------------
-  async click(input, threadId) {
-    try {
-      const page = await this.getPage(threadId);
-      const locator = await this.requireLocator(input.ref, threadId);
-      if (!locator) {
-        return this.createError(
-          "stale_ref",
-          `Ref ${input.ref} not found. The page has changed.`,
-          "Take a new snapshot to see the current page state and get fresh refs."
-        );
-      }
-      const timeout = input.timeout ?? this.defaultTimeout;
-      const navigation = this.startNavigationWait(page, input.waitUntil, timeout);
-      await locator.click({
-        button: input.button ?? "left",
-        clickCount: input.clickCount ?? 1,
-        modifiers: input.modifiers,
-        timeout
-      });
-      await navigation;
-      return {
-        success: true,
-        url: page.url(),
-        hint: "Take a new snapshot to see updated page state and get fresh refs."
-      };
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      if (errorMsg.includes("intercepts pointer events")) {
-        return this.createError(
-          "element_blocked",
-          `Element ${input.ref} is blocked by another element.`,
-          "Take a new snapshot to see what is blocking. Dismiss any modals or scroll the element into view."
-        );
-      }
-      return this.createErrorFromException(error, "Click");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // 4. browser_type - Type text into element
-  // ---------------------------------------------------------------------------
-  async type(input, threadId) {
-    try {
-      const page = await this.getPage(threadId);
-      const locator = await this.requireLocator(input.ref, threadId);
-      if (!locator) {
-        return this.createError(
-          "stale_ref",
-          `Ref ${input.ref} not found. The page has changed.`,
-          "Take a new snapshot to see the current page state and get fresh refs."
-        );
-      }
-      if (input.clear) {
-        await locator.fill("", { timeout: this.defaultTimeout });
-      }
-      if (input.delay) {
-        await locator.focus();
-        for (const char of input.text) {
-          await page.keyboard.press(char);
-          await new Promise((r) => setTimeout(r, input.delay));
-        }
-      } else {
-        await locator.fill(input.text, { timeout: this.defaultTimeout });
-      }
-      const value = await locator.inputValue({ timeout: 1e3 }).catch(() => input.text);
-      return {
-        success: true,
-        value,
-        url: page.url(),
-        hint: "Take a new snapshot if you need to interact with more elements."
-      };
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      if (errorMsg.includes("is not an <input>") || errorMsg.includes("not an input") || errorMsg.includes("Cannot type") || errorMsg.includes("not focusable")) {
-        return this.createError(
-          "not_focusable",
-          `Element ${input.ref} is not a text input field.`,
-          'Take a new snapshot and look for elements with role "textbox" or "searchbox".'
-        );
-      }
-      return this.createErrorFromException(error, "Type");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // 5. browser_press - Press keyboard key(s)
-  // ---------------------------------------------------------------------------
-  async press(input, threadId) {
-    try {
-      const page = await this.getPage(threadId);
-      const timeout = input.timeout ?? this.defaultTimeout;
-      const navigation = this.startNavigationWait(page, input.waitUntil, timeout);
-      await page.keyboard.press(input.key);
-      await navigation;
-      return {
-        success: true,
-        url: page.url(),
-        hint: "Take a new snapshot if the page may have changed."
-      };
-    } catch (error) {
-      return this.createErrorFromException(error, "Press");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // 6. browser_select - Select dropdown option
-  // ---------------------------------------------------------------------------
-  async select(input, threadId) {
-    try {
-      const page = await this.getPage(threadId);
-      const locator = await this.requireLocator(input.ref, threadId);
-      if (!locator) {
-        return this.createError(
-          "stale_ref",
-          `Ref ${input.ref} not found. The page has changed.`,
-          "Take a new snapshot to get fresh refs."
-        );
-      }
-      const selectValue = {};
-      if (input.value) selectValue.value = input.value;
-      if (input.label) selectValue.label = input.label;
-      if (input.index !== void 0) selectValue.index = input.index;
-      const timeout = input.timeout ?? this.defaultTimeout;
-      const navigation = this.startNavigationWait(page, input.waitUntil, timeout);
-      const selected = await locator.selectOption(selectValue, { timeout });
-      await navigation;
-      return {
-        success: true,
-        selected,
-        url: page.url(),
-        hint: "Selection complete. Take a snapshot if you need to continue."
-      };
-    } catch (error) {
-      return this.createErrorFromException(error, "Select");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // 7. browser_scroll - Scroll page or element
-  // ---------------------------------------------------------------------------
-  async scroll(input, threadId) {
-    try {
-      const page = await this.getPage(threadId);
-      if (input.ref) {
-        const locator = await this.requireLocator(input.ref, threadId);
-        if (locator) {
-          await locator.scrollIntoViewIfNeeded({ timeout: this.defaultTimeout });
-        }
-      } else {
-        const direction = input.direction;
-        const amount = input.amount ?? 300;
-        let deltaX = 0;
-        let deltaY = 0;
-        switch (direction) {
-          case "up":
-            deltaY = -amount;
-            break;
-          case "down":
-            deltaY = amount;
-            break;
-          case "left":
-            deltaX = -amount;
-            break;
-          case "right":
-            deltaX = amount;
-            break;
-        }
-        await page.evaluate(
-          ({ x, y }) => {
-            globalThis.scrollBy(x, y);
-          },
-          { x: deltaX, y: deltaY }
-        );
-      }
-      const scrollInfo = await this.getScrollInfo(threadId);
-      let scrollText;
-      if (scrollInfo.atTop && !scrollInfo.atBottom) {
-        scrollText = "TOP - more content below";
-      } else if (scrollInfo.atBottom) {
-        scrollText = "BOTTOM of page";
-      } else {
-        scrollText = `${scrollInfo.percentDown}% down`;
-      }
-      return {
-        success: true,
-        position: { x: 0, y: scrollInfo.scrollY },
-        scroll: scrollText,
-        hint: "Take a new snapshot to see elements in the new viewport."
-      };
-    } catch (error) {
-      return this.createErrorFromException(error, "Scroll");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // 8. browser_hover - Hover over element
-  // ---------------------------------------------------------------------------
-  async hover(input, threadId) {
-    try {
-      const page = await this.getPage(threadId);
-      const locator = await this.requireLocator(input.ref, threadId);
-      if (!locator) {
-        return this.createError(
-          "stale_ref",
-          `Ref ${input.ref} not found. The page has changed.`,
-          "Take a new snapshot to get fresh refs."
-        );
-      }
-      await locator.hover({ timeout: this.defaultTimeout });
-      return {
-        success: true,
-        url: page.url(),
-        hint: "Take a new snapshot to see any hover-triggered elements (dropdowns, tooltips)."
-      };
-    } catch (error) {
-      return this.createErrorFromException(error, "Hover");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // 10. browser_back - Navigate back
-  // ---------------------------------------------------------------------------
-  async back(threadId) {
-    try {
-      const page = await this.getPage(threadId);
-      await page.goBack({ timeout: this.defaultTimeout });
-      const url = page.url();
-      this.markActiveUrlChangeSource("agent", url, threadId);
-      return {
-        success: true,
-        url,
-        title: await page.title(),
-        hint: "Take a new snapshot to see the previous page."
-      };
-    } catch (error) {
-      return this.createErrorFromException(error, "Back");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // 11. browser_dialog - Click element that triggers dialog and handle it
-  // ---------------------------------------------------------------------------
-  async dialog(input, threadId) {
-    try {
-      const page = await this.getPage(threadId);
-      const locator = await this.requireLocator(input.triggerRef, threadId);
-      if (!locator) {
-        return this.createError(
-          "stale_ref",
-          `Trigger ref ${input.triggerRef} not found.`,
-          "Take a new snapshot to get fresh refs."
-        );
-      }
-      return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          page.off("dialog", dialogHandler);
-          reject(
-            new Error(`No dialog appeared after clicking ${input.triggerRef}. The element may not trigger a dialog.`)
-          );
-        }, this.defaultTimeout);
-        const dialogHandler = async (dialog) => {
-          clearTimeout(timeout);
-          try {
-            const dialogType = dialog.type();
-            const message = dialog.message();
-            if (input.action === "accept") {
-              await dialog.accept(input.text);
-            } else {
-              await dialog.dismiss();
-            }
-            resolve({
-              success: true,
-              action: input.action,
-              dialogType,
-              message,
-              hint: "Dialog handled. Take a snapshot to continue."
-            });
-          } catch (e) {
-            reject(e);
-          }
-        };
-        page.once("dialog", dialogHandler);
-        locator.click({ timeout: this.defaultTimeout }).catch((e) => {
-          clearTimeout(timeout);
-          page.off("dialog", dialogHandler);
-          reject(e);
-        });
-      });
-    } catch (error) {
-      return this.createErrorFromException(error, "Dialog");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // 13. browser_wait - Wait for element or condition
-  // ---------------------------------------------------------------------------
-  async wait(input, threadId) {
-    try {
-      const timeout = input.timeout ?? this.defaultTimeout;
-      if (input.ref) {
-        const locator = await this.requireLocator(input.ref, threadId);
-        if (!locator) {
-          return this.createError("stale_ref", `Ref ${input.ref} not found.`, "Take a new snapshot to get fresh refs.");
-        }
-        const state = input.state ?? "visible";
-        await locator.waitFor({ state, timeout });
-        return {
-          success: true,
-          hint: `Element is now ${state}. Take a snapshot to continue.`
-        };
-      } else {
-        const page = await this.getPage(threadId);
-        await page.waitForTimeout(timeout);
-        return {
-          success: true,
-          hint: "Wait complete. Take a snapshot to see current state."
-        };
-      }
-    } catch (error) {
-      return this.createErrorFromException(error, "Wait");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // 14. browser_tabs - Manage browser tabs
-  // ---------------------------------------------------------------------------
-  async tabs(input, threadId) {
-    try {
-      const browser = await this.getManagerForThread(threadId);
-      if (!browser) {
-        return this.createError(
-          "browser_closed",
-          "Browser not launched",
-          "Call a navigation tool first to launch the browser."
-        );
-      }
-      switch (input.action) {
-        case "list": {
-          if (!browser.listTabs) {
-            return this.createError(
-              "browser_error",
-              "Tab management not supported",
-              "This browser provider does not support tab management."
-            );
-          }
-          const tabsList = await browser.listTabs();
-          return {
-            success: true,
-            tabs: tabsList,
-            hint: 'Use browser_tabs with action:"switch" and index to change tabs.'
-          };
-        }
-        case "new": {
-          if (!browser.newTab) {
-            return this.createError(
-              "browser_error",
-              "Tab management not supported",
-              "This browser provider does not support tab management."
-            );
-          }
-          const result = await browser.newTab();
-          if (input.url) {
-            const page = await this.getPage(threadId);
-            await page.goto(input.url);
-            this.markActiveUrlChangeSource("agent", page.url(), threadId);
-          }
-          this.updateSessionBrowserState(threadId);
-          return {
-            success: true,
-            ...result,
-            hint: "New tab opened. Take a snapshot to see its content."
-          };
-        }
-        case "switch": {
-          if (!browser.switchTo) {
-            return this.createError(
-              "browser_error",
-              "Tab management not supported",
-              "This browser provider does not support tab management."
-            );
-          }
-          await browser.switchTo(input.index);
-          await this.reconnectScreencastForThread(threadId, "tab switch");
-          const page = browser.getPage();
-          const pageUrl = page.url();
-          this.markActiveUrlChangeSource("agent", pageUrl, threadId);
-          const streamKey = this.getStreamKey(threadId);
-          const stream = this.activeScreencastStreams.get(streamKey);
-          if (pageUrl && stream?.isActive()) {
-            stream.emitUrl(pageUrl);
-          }
-          this.updateSessionBrowserState(threadId);
-          return {
-            success: true,
-            index: input.index,
-            url: pageUrl,
-            title: await page.title(),
-            hint: "Tab switched. Take a snapshot to see its content."
-          };
-        }
-        case "close": {
-          if (!browser.closeTab) {
-            return this.createError(
-              "browser_error",
-              "Tab management not supported",
-              "This browser provider does not support tab management."
-            );
-          }
-          await browser.closeTab(input.index);
-          await this.reconnectScreencastForThread(threadId, "tab close");
-          this.updateSessionBrowserState(threadId);
-          const tabsList = await browser.listTabs?.() ?? [];
-          return {
-            success: true,
-            remaining: tabsList.length,
-            hint: tabsList.length > 0 ? "Tab closed. Take a snapshot to see current tab." : "All tabs closed."
-          };
-        }
-        default:
-          return this.createError(
-            "browser_error",
-            `Unknown tabs action: ${input.action}`,
-            'Use "list", "new", "switch", or "close".'
-          );
-      }
-    } catch (error) {
-      return this.createErrorFromException(error, "Tabs");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // 15. browser_drag - Drag element to target
-  // ---------------------------------------------------------------------------
-  async drag(input, threadId) {
-    try {
-      const page = await this.getPage(threadId);
-      let sourceLocator = null;
-      if (input.sourceRef) {
-        sourceLocator = await this.requireLocator(input.sourceRef, threadId);
-      } else if (input.sourceSelector) {
-        sourceLocator = page.locator(input.sourceSelector);
-      }
-      if (!sourceLocator) {
-        return this.createError(
-          "stale_ref",
-          input.sourceRef ? `Source ref ${input.sourceRef} not found.` : "No source element specified. Provide sourceRef or sourceSelector.",
-          input.sourceRef ? "Take a new snapshot to get fresh refs, or use sourceSelector for elements not in the accessibility tree." : void 0
-        );
-      }
-      let targetLocator = null;
-      if (input.targetRef) {
-        targetLocator = await this.requireLocator(input.targetRef, threadId);
-      } else if (input.targetSelector) {
-        targetLocator = page.locator(input.targetSelector);
-      }
-      if (!targetLocator) {
-        return this.createError(
-          "stale_ref",
-          input.targetRef ? `Target ref ${input.targetRef} not found.` : "No target element specified. Provide targetRef or targetSelector.",
-          input.targetRef ? "Take a new snapshot to get fresh refs, or use targetSelector for elements not in the accessibility tree." : void 0
-        );
-      }
-      await sourceLocator.dragTo(targetLocator, { timeout: this.defaultTimeout });
-      return {
-        success: true,
-        url: page.url(),
-        hint: "Drag complete. Take a snapshot to see the result."
-      };
-    } catch (error) {
-      return this.createErrorFromException(error, "Drag");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // 16. browser_evaluate - Execute JavaScript
-  // ---------------------------------------------------------------------------
-  async evaluate(input, threadId) {
-    try {
-      const page = await this.getPage(threadId);
-      const result = await page.evaluate(input.script);
-      return {
-        success: true,
-        result,
-        hint: "JavaScript executed. Take a snapshot if the page may have changed."
-      };
-    } catch (error) {
-      return this.createErrorFromException(error, "Evaluate");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // 17. browser_close - Close browser
-  // ---------------------------------------------------------------------------
-  async closeBrowser() {
-    try {
-      await this.close();
-      return {
-        success: true,
-        hint: "Browser closed. Call browser_goto to start a new session."
-      };
-    } catch (error) {
-      return this.createErrorFromException(error, "Close");
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // Screencast (for Studio live view)
-  // ---------------------------------------------------------------------------
-  async startScreencast(_options) {
-    const requestedThreadId = _options?.threadId;
-    const effectiveThreadId = this.getScope() === "thread" ? requestedThreadId ?? this.getCurrentThread() ?? DEFAULT_THREAD_ID : requestedThreadId;
-    let browserManager;
-    if (this.getScope() === "thread") {
-      browserManager = await this.getManagerForThread(effectiveThreadId);
-    } else {
-      if (!this.sharedManager) throw new Error("Browser not launched");
-      browserManager = this.sharedManager;
-    }
-    const provider = {
-      getCdpSession: async () => {
-        const currentPage = browserManager.getPage();
-        if (!currentPage) {
-          throw new Error("No active page available");
-        }
-        const cdpSession = await currentPage.context().newCDPSession(currentPage);
-        return cdpSession;
-      },
-      isBrowserRunning: () => browserManager.isLaunched()
-    };
-    const stream = new ScreencastStreamImpl(provider, _options);
-    const streamKey = this.getStreamKey(effectiveThreadId);
-    this.activeScreencastStreams.set(streamKey, stream);
-    const context = browserManager.getContext();
-    if (context) {
-      const onNewPage = (_newPage) => {
-        setTimeout(() => {
-          if (stream.isActive()) {
-            stream.reconnect().catch(() => {
-            });
-          }
-        }, 100);
-      };
-      context.on("page", onNewPage);
-      const pageCloseHandlers = /* @__PURE__ */ new Map();
-      const frameNavigatedHandlers = /* @__PURE__ */ new Map();
-      const setupPageListeners = (page) => {
-        const onFrameNavigated = (frame) => {
-          if (!frame.parentFrame()) {
-            stream.emitUrl(frame.url());
-            this.updateSessionBrowserState(effectiveThreadId);
-          }
-        };
-        page.on("framenavigated", onFrameNavigated);
-        frameNavigatedHandlers.set(page, onFrameNavigated);
-        const onClose = () => {
-          pageCloseHandlers.delete(page);
-          const navHandler = frameNavigatedHandlers.get(page);
-          if (navHandler) {
-            page.off("framenavigated", navHandler);
-            frameNavigatedHandlers.delete(page);
-          }
-          setTimeout(() => {
-            const remainingPages = browserManager.getPages();
-            if (stream.isActive() && remainingPages.length > 0) {
-              stream.reconnect().catch(() => {
-              });
-              const activePage = remainingPages[browserManager.getActiveIndex()] || remainingPages[0];
-              if (activePage) {
-                const url = activePage.url();
-                if (url && url !== "about:blank") {
-                  stream.emitUrl(url);
-                }
-              }
-            }
-          }, 100);
-        };
-        page.once("close", onClose);
-        pageCloseHandlers.set(page, onClose);
-      };
-      const setupPageCloseListener = setupPageListeners;
-      for (const page of browserManager.getPages()) {
-        setupPageCloseListener(page);
-      }
-      const onNewPageWithCloseListener = (newPage) => {
-        setupPageCloseListener(newPage);
-        const url = newPage.url();
-        if (url && url !== "about:blank") {
-          stream.emitUrl(url);
-        }
-        onNewPage();
-      };
-      context.off("page", onNewPage);
-      context.on("page", onNewPageWithCloseListener);
-      stream.once("stop", () => {
-        context.off("page", onNewPageWithCloseListener);
-        for (const [page, handler] of pageCloseHandlers) {
-          page.off("close", handler);
-        }
-        pageCloseHandlers.clear();
-        for (const [page, handler] of frameNavigatedHandlers) {
-          page.off("framenavigated", handler);
-        }
-        frameNavigatedHandlers.clear();
-        this.activeScreencastStreams.delete(streamKey);
-      });
-    }
-    await stream.start();
-    return stream;
-  }
-  // ---------------------------------------------------------------------------
-  // Event Injection (for Studio live view interactivity)
-  // ---------------------------------------------------------------------------
-  async injectMouseEvent(event, threadId) {
-    const effectiveThreadId = threadId ?? this.getCurrentThread();
-    const manager = await this.getManagerForThread(effectiveThreadId);
-    await manager.injectMouseEvent(event);
-  }
-  async injectKeyboardEvent(event, threadId) {
-    const effectiveThreadId = threadId ?? this.getCurrentThread();
-    const manager = await this.getManagerForThread(effectiveThreadId);
-    const cdp = await manager.getCDPSession();
-    await cdp.send("Input.dispatchKeyEvent", {
-      type: event.type,
-      key: event.key,
-      code: event.code,
-      text: event.text,
-      modifiers: event.modifiers ?? 0,
-      windowsVirtualKeyCode: event.windowsVirtualKeyCode
-    });
-  }
+		if (!info || typeof info.scrollHeight !== "number") return {
+			scrollY: 0,
+			scrollHeight: 0,
+			viewportHeight: 0,
+			atTop: true,
+			atBottom: true,
+			percentDown: 0
+		};
+		const maxScroll = info.scrollHeight - info.viewportHeight;
+		return {
+			...info,
+			atTop: info.scrollY < 50,
+			atBottom: info.scrollY >= maxScroll - 50,
+			percentDown: maxScroll > 0 ? Math.round(info.scrollY / maxScroll * 100) : 0
+		};
+	}
+	/**
+	* Get the current page URL without launching the browser.
+	* @param threadId - Optional thread ID for thread-isolated browsers
+	* @returns The current URL string, or null if browser is not running
+	*/
+	async getCurrentUrl(threadId) {
+		if (!this.isBrowserRunning()) return null;
+		try {
+			const effectiveThreadId = threadId ?? this.getCurrentThread();
+			if (this.threadManager.getScope() === "thread" && effectiveThreadId) {
+				const manager = this.threadManager.getExistingManagerForThread(effectiveThreadId);
+				if (!manager) return null;
+				const url = manager.getPage().url();
+				if (url && url !== "about:blank") {
+					const state = this.getBrowserStateForManager(manager);
+					if (state) this.threadManager.updateBrowserState(effectiveThreadId, state);
+				}
+				return url;
+			}
+			const manager = await this.getManagerForThread(threadId);
+			const url = manager.getPage().url();
+			if (url && url !== "about:blank") {
+				const state = this.getBrowserStateForManager(manager);
+				if (state) this.lastBrowserState = state;
+			}
+			return url;
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Navigate to a URL (simple form). Used internally for restoring state on relaunch.
+	*/
+	async navigateTo(url) {
+		if (!this.isBrowserRunning()) return;
+		try {
+			await (await this.getPage()).goto(url, {
+				timeout: this.defaultTimeout,
+				waitUntil: "domcontentloaded"
+			});
+		} catch {}
+	}
+	/**
+	* Get the current browser state (all tabs and active tab index).
+	*/
+	async getBrowserState(threadId) {
+		if (!this.isBrowserRunning(threadId)) return null;
+		try {
+			const manager = await this.getManagerForThread(threadId);
+			return this.getBrowserStateForManager(manager, threadId);
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Get browser state for a thread (implements abstract method from base class).
+	* Sync version that uses existing manager lookup without creating sessions.
+	*/
+	getBrowserStateForThread(threadId) {
+		const effectiveThreadId = threadId ?? this.getCurrentThread() ?? DEFAULT_THREAD_ID;
+		const manager = this.threadManager.getExistingManagerForThread(effectiveThreadId);
+		if (!manager) return null;
+		return this.getBrowserStateForManager(manager, effectiveThreadId);
+	}
+	/**
+	* Get browser state from a specific manager instance.
+	*/
+	getBrowserStateForManager(manager, threadId) {
+		try {
+			const stateKey = this.browserStateKey(threadId);
+			const pages = manager.getPages();
+			const activeIndex = manager.getActiveIndex();
+			const tabs = pages.map((page) => ({ url: page.url() }));
+			const activeUrl = tabs[activeIndex]?.url;
+			const previousState = this.threadManager.getSavedBrowserState(stateKey) ?? this.lastBrowserState;
+			const previousUrl = previousState?.tabs[previousState.activeTabIndex]?.url;
+			const activeUrlChangeSource = this.getActiveUrlChangeSource(activeUrl, stateKey) ?? (previousUrl && activeUrl !== previousUrl ? "user" : void 0);
+			const state = {
+				tabs,
+				activeTabIndex: activeIndex,
+				...this.getCloseReason(stateKey) ? { closeReason: this.getCloseReason(stateKey) } : {},
+				...activeUrlChangeSource ? { activeUrlChangeSource } : {}
+			};
+			this.threadManager.updateBrowserState(stateKey, state);
+			this.lastBrowserState = state;
+			return state;
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Get all open tabs with their URLs and titles.
+	*/
+	async getTabState(threadId) {
+		return (await this.getBrowserState(threadId))?.tabs ?? [];
+	}
+	/**
+	* Get the active tab index.
+	*/
+	async getActiveTabIndex(threadId) {
+		if (!this.isBrowserRunning()) return 0;
+		try {
+			return (await this.getManagerForThread(threadId)).getActiveIndex();
+		} catch {
+			return 0;
+		}
+	}
+	/**
+	* Export the current browser session's storage state (cookies, localStorage) to a JSON file.
+	* This can later be loaded via the `storageState` config option to restore the session.
+	*
+	* @param path - File path to save the storage state JSON
+	* @param threadId - Optional thread ID (defaults to current thread)
+	*/
+	async exportStorageState(path, threadId) {
+		const effectiveThreadId = threadId ?? this.getCurrentThread();
+		const manager = this.threadManager.getExistingManagerForThread(effectiveThreadId);
+		if (!manager) throw new Error("No browser is running. Launch a browser first before exporting storage state.");
+		const context = manager.getContext();
+		if (!context) throw new Error("Browser context not available");
+		await context.storageState({ path });
+	}
+	async goto(input, threadId) {
+		try {
+			const page = await this.getPage(threadId);
+			await page.goto(input.url, {
+				timeout: input.timeout ?? this.defaultTimeout,
+				waitUntil: input.waitUntil ?? "domcontentloaded"
+			});
+			const url = page.url();
+			this.markActiveUrlChangeSource("agent", url, threadId);
+			return {
+				success: true,
+				url,
+				title: await page.title(),
+				hint: "Take a snapshot to see interactive elements and get refs."
+			};
+		} catch (error) {
+			return this.createErrorFromException(error, "Goto");
+		}
+	}
+	async snapshot(input, threadId) {
+		try {
+			const manager = await this.getManagerForThread(threadId);
+			const page = await this.getPage(threadId);
+			const snapshot = ((await manager.getSnapshot({
+				interactive: input.interactiveOnly ?? true,
+				compact: true
+			})).tree ?? "").replace(/\[ref=(\w+)\]/g, "@$1");
+			const scrollInfo = await this.getScrollInfo(threadId);
+			let scrollText;
+			if (scrollInfo.atTop && !scrollInfo.atBottom) scrollText = "TOP - more content below";
+			else if (scrollInfo.atBottom) scrollText = "BOTTOM of page";
+			else scrollText = `${scrollInfo.percentDown}% down`;
+			const refs = snapshot.match(/@e\d+/g) || [];
+			const elementCount = new Set(refs).size;
+			return {
+				success: true,
+				snapshot,
+				url: page.url(),
+				title: await page.title(),
+				elementCount,
+				scroll: scrollText,
+				hint: elementCount === 0 ? "No interactive elements found. Try scrolling or setting interactiveOnly:false." : void 0
+			};
+		} catch (error) {
+			return this.createErrorFromException(error, "Snapshot");
+		}
+	}
+	async screenshot(input, threadId) {
+		try {
+			const page = await this.getPage(threadId);
+			const buffer = await page.screenshot({
+				fullPage: input.fullPage ?? false,
+				type: "png"
+			});
+			return {
+				base64: Buffer.from(buffer).toString("base64"),
+				url: page.url(),
+				title: await page.title()
+			};
+		} catch (error) {
+			return this.createErrorFromException(error, "Screenshot");
+		}
+	}
+	/**
+	* Start a `waitForNavigation` wait (when `waitUntil` is set) and immediately
+	* attach a noop catch handler so a navigation timeout/rejection can't become
+	* an unhandled rejection (crashing the process) while the caller's action is
+	* still pending. Callers should still `await` the returned promise to observe
+	* the original error.
+	*/
+	startNavigationWait(page, waitUntil, timeout) {
+		const navigation = waitUntil ? page.waitForNavigation({
+			waitUntil,
+			timeout
+		}) : void 0;
+		navigation?.catch(() => {});
+		return navigation;
+	}
+	async click(input, threadId) {
+		try {
+			const page = await this.getPage(threadId);
+			const locator = await this.requireLocator(input.ref, threadId);
+			if (!locator) return this.createError("stale_ref", `Ref ${input.ref} not found. The page has changed.`, "Take a new snapshot to see the current page state and get fresh refs.");
+			const timeout = input.timeout ?? this.defaultTimeout;
+			const navigation = this.startNavigationWait(page, input.waitUntil, timeout);
+			await locator.click({
+				button: input.button ?? "left",
+				clickCount: input.clickCount ?? 1,
+				modifiers: input.modifiers,
+				timeout
+			});
+			await navigation;
+			return {
+				success: true,
+				url: page.url(),
+				hint: "Take a new snapshot to see updated page state and get fresh refs."
+			};
+		} catch (error) {
+			if ((error instanceof Error ? error.message : String(error)).includes("intercepts pointer events")) return this.createError("element_blocked", `Element ${input.ref} is blocked by another element.`, "Take a new snapshot to see what is blocking. Dismiss any modals or scroll the element into view.");
+			return this.createErrorFromException(error, "Click");
+		}
+	}
+	async type(input, threadId) {
+		try {
+			const page = await this.getPage(threadId);
+			const locator = await this.requireLocator(input.ref, threadId);
+			if (!locator) return this.createError("stale_ref", `Ref ${input.ref} not found. The page has changed.`, "Take a new snapshot to see the current page state and get fresh refs.");
+			if (input.clear) await locator.fill("", { timeout: this.defaultTimeout });
+			if (input.delay) {
+				await locator.focus();
+				for (const char of input.text) {
+					await page.keyboard.press(char);
+					await new Promise((r) => setTimeout(r, input.delay));
+				}
+			} else await locator.fill(input.text, { timeout: this.defaultTimeout });
+			return {
+				success: true,
+				value: await locator.inputValue({ timeout: 1e3 }).catch(() => input.text),
+				url: page.url(),
+				hint: "Take a new snapshot if you need to interact with more elements."
+			};
+		} catch (error) {
+			const errorMsg = error instanceof Error ? error.message : String(error);
+			if (errorMsg.includes("is not an <input>") || errorMsg.includes("not an input") || errorMsg.includes("Cannot type") || errorMsg.includes("not focusable")) return this.createError("not_focusable", `Element ${input.ref} is not a text input field.`, "Take a new snapshot and look for elements with role \"textbox\" or \"searchbox\".");
+			return this.createErrorFromException(error, "Type");
+		}
+	}
+	async press(input, threadId) {
+		try {
+			const page = await this.getPage(threadId);
+			const timeout = input.timeout ?? this.defaultTimeout;
+			const navigation = this.startNavigationWait(page, input.waitUntil, timeout);
+			await page.keyboard.press(input.key);
+			await navigation;
+			return {
+				success: true,
+				url: page.url(),
+				hint: "Take a new snapshot if the page may have changed."
+			};
+		} catch (error) {
+			return this.createErrorFromException(error, "Press");
+		}
+	}
+	async select(input, threadId) {
+		try {
+			const page = await this.getPage(threadId);
+			const locator = await this.requireLocator(input.ref, threadId);
+			if (!locator) return this.createError("stale_ref", `Ref ${input.ref} not found. The page has changed.`, "Take a new snapshot to get fresh refs.");
+			const selectValue = {};
+			if (input.value) selectValue.value = input.value;
+			if (input.label) selectValue.label = input.label;
+			if (input.index !== void 0) selectValue.index = input.index;
+			const timeout = input.timeout ?? this.defaultTimeout;
+			const navigation = this.startNavigationWait(page, input.waitUntil, timeout);
+			const selected = await locator.selectOption(selectValue, { timeout });
+			await navigation;
+			return {
+				success: true,
+				selected,
+				url: page.url(),
+				hint: "Selection complete. Take a snapshot if you need to continue."
+			};
+		} catch (error) {
+			return this.createErrorFromException(error, "Select");
+		}
+	}
+	async scroll(input, threadId) {
+		try {
+			const page = await this.getPage(threadId);
+			if (input.ref) {
+				const locator = await this.requireLocator(input.ref, threadId);
+				if (locator) await locator.scrollIntoViewIfNeeded({ timeout: this.defaultTimeout });
+			} else {
+				const direction = input.direction;
+				const amount = input.amount ?? 300;
+				let deltaX = 0;
+				let deltaY = 0;
+				switch (direction) {
+					case "up":
+						deltaY = -amount;
+						break;
+					case "down":
+						deltaY = amount;
+						break;
+					case "left":
+						deltaX = -amount;
+						break;
+					case "right":
+						deltaX = amount;
+						break;
+				}
+				await page.evaluate(({ x, y }) => {
+					globalThis.scrollBy(x, y);
+				}, {
+					x: deltaX,
+					y: deltaY
+				});
+			}
+			const scrollInfo = await this.getScrollInfo(threadId);
+			let scrollText;
+			if (scrollInfo.atTop && !scrollInfo.atBottom) scrollText = "TOP - more content below";
+			else if (scrollInfo.atBottom) scrollText = "BOTTOM of page";
+			else scrollText = `${scrollInfo.percentDown}% down`;
+			return {
+				success: true,
+				position: {
+					x: 0,
+					y: scrollInfo.scrollY
+				},
+				scroll: scrollText,
+				hint: "Take a new snapshot to see elements in the new viewport."
+			};
+		} catch (error) {
+			return this.createErrorFromException(error, "Scroll");
+		}
+	}
+	async hover(input, threadId) {
+		try {
+			const page = await this.getPage(threadId);
+			const locator = await this.requireLocator(input.ref, threadId);
+			if (!locator) return this.createError("stale_ref", `Ref ${input.ref} not found. The page has changed.`, "Take a new snapshot to get fresh refs.");
+			await locator.hover({ timeout: this.defaultTimeout });
+			return {
+				success: true,
+				url: page.url(),
+				hint: "Take a new snapshot to see any hover-triggered elements (dropdowns, tooltips)."
+			};
+		} catch (error) {
+			return this.createErrorFromException(error, "Hover");
+		}
+	}
+	async back(threadId) {
+		try {
+			const page = await this.getPage(threadId);
+			await page.goBack({ timeout: this.defaultTimeout });
+			const url = page.url();
+			this.markActiveUrlChangeSource("agent", url, threadId);
+			return {
+				success: true,
+				url,
+				title: await page.title(),
+				hint: "Take a new snapshot to see the previous page."
+			};
+		} catch (error) {
+			return this.createErrorFromException(error, "Back");
+		}
+	}
+	async dialog(input, threadId) {
+		try {
+			const page = await this.getPage(threadId);
+			const locator = await this.requireLocator(input.triggerRef, threadId);
+			if (!locator) return this.createError("stale_ref", `Trigger ref ${input.triggerRef} not found.`, "Take a new snapshot to get fresh refs.");
+			return new Promise((resolve, reject) => {
+				const timeout = setTimeout(() => {
+					page.off("dialog", dialogHandler);
+					reject(/* @__PURE__ */ new Error(`No dialog appeared after clicking ${input.triggerRef}. The element may not trigger a dialog.`));
+				}, this.defaultTimeout);
+				const dialogHandler = async (dialog) => {
+					clearTimeout(timeout);
+					try {
+						const dialogType = dialog.type();
+						const message = dialog.message();
+						if (input.action === "accept") await dialog.accept(input.text);
+						else await dialog.dismiss();
+						resolve({
+							success: true,
+							action: input.action,
+							dialogType,
+							message,
+							hint: "Dialog handled. Take a snapshot to continue."
+						});
+					} catch (e) {
+						reject(e);
+					}
+				};
+				page.once("dialog", dialogHandler);
+				locator.click({ timeout: this.defaultTimeout }).catch((e) => {
+					clearTimeout(timeout);
+					page.off("dialog", dialogHandler);
+					reject(e);
+				});
+			});
+		} catch (error) {
+			return this.createErrorFromException(error, "Dialog");
+		}
+	}
+	async wait(input, threadId) {
+		try {
+			const timeout = input.timeout ?? this.defaultTimeout;
+			if (input.ref) {
+				const locator = await this.requireLocator(input.ref, threadId);
+				if (!locator) return this.createError("stale_ref", `Ref ${input.ref} not found.`, "Take a new snapshot to get fresh refs.");
+				const state = input.state ?? "visible";
+				await locator.waitFor({
+					state,
+					timeout
+				});
+				return {
+					success: true,
+					hint: `Element is now ${state}. Take a snapshot to continue.`
+				};
+			} else {
+				await (await this.getPage(threadId)).waitForTimeout(timeout);
+				return {
+					success: true,
+					hint: "Wait complete. Take a snapshot to see current state."
+				};
+			}
+		} catch (error) {
+			return this.createErrorFromException(error, "Wait");
+		}
+	}
+	async tabs(input, threadId) {
+		try {
+			const browser = await this.getManagerForThread(threadId);
+			if (!browser) return this.createError("browser_closed", "Browser not launched", "Call a navigation tool first to launch the browser.");
+			switch (input.action) {
+				case "list":
+					if (!browser.listTabs) return this.createError("browser_error", "Tab management not supported", "This browser provider does not support tab management.");
+					return {
+						success: true,
+						tabs: await browser.listTabs(),
+						hint: "Use browser_tabs with action:\"switch\" and index to change tabs."
+					};
+				case "new": {
+					if (!browser.newTab) return this.createError("browser_error", "Tab management not supported", "This browser provider does not support tab management.");
+					const result = await browser.newTab();
+					if (input.url) {
+						const page = await this.getPage(threadId);
+						await page.goto(input.url);
+						this.markActiveUrlChangeSource("agent", page.url(), threadId);
+					}
+					this.updateSessionBrowserState(threadId);
+					return {
+						success: true,
+						...result,
+						hint: "New tab opened. Take a snapshot to see its content."
+					};
+				}
+				case "switch": {
+					if (!browser.switchTo) return this.createError("browser_error", "Tab management not supported", "This browser provider does not support tab management.");
+					await browser.switchTo(input.index);
+					await this.reconnectScreencastForThread(threadId, "tab switch");
+					const page = browser.getPage();
+					const pageUrl = page.url();
+					this.markActiveUrlChangeSource("agent", pageUrl, threadId);
+					const streamKey = this.getStreamKey(threadId);
+					const stream = this.activeScreencastStreams.get(streamKey);
+					if (pageUrl && stream?.isActive()) stream.emitUrl(pageUrl);
+					this.updateSessionBrowserState(threadId);
+					return {
+						success: true,
+						index: input.index,
+						url: pageUrl,
+						title: await page.title(),
+						hint: "Tab switched. Take a snapshot to see its content."
+					};
+				}
+				case "close": {
+					if (!browser.closeTab) return this.createError("browser_error", "Tab management not supported", "This browser provider does not support tab management.");
+					await browser.closeTab(input.index);
+					await this.reconnectScreencastForThread(threadId, "tab close");
+					this.updateSessionBrowserState(threadId);
+					const tabsList = await browser.listTabs?.() ?? [];
+					return {
+						success: true,
+						remaining: tabsList.length,
+						hint: tabsList.length > 0 ? "Tab closed. Take a snapshot to see current tab." : "All tabs closed."
+					};
+				}
+				default: return this.createError("browser_error", `Unknown tabs action: ${input.action}`, "Use \"list\", \"new\", \"switch\", or \"close\".");
+			}
+		} catch (error) {
+			return this.createErrorFromException(error, "Tabs");
+		}
+	}
+	async drag(input, threadId) {
+		try {
+			const page = await this.getPage(threadId);
+			let sourceLocator = null;
+			if (input.sourceRef) sourceLocator = await this.requireLocator(input.sourceRef, threadId);
+			else if (input.sourceSelector) sourceLocator = page.locator(input.sourceSelector);
+			if (!sourceLocator) return this.createError("stale_ref", input.sourceRef ? `Source ref ${input.sourceRef} not found.` : "No source element specified. Provide sourceRef or sourceSelector.", input.sourceRef ? "Take a new snapshot to get fresh refs, or use sourceSelector for elements not in the accessibility tree." : void 0);
+			let targetLocator = null;
+			if (input.targetRef) targetLocator = await this.requireLocator(input.targetRef, threadId);
+			else if (input.targetSelector) targetLocator = page.locator(input.targetSelector);
+			if (!targetLocator) return this.createError("stale_ref", input.targetRef ? `Target ref ${input.targetRef} not found.` : "No target element specified. Provide targetRef or targetSelector.", input.targetRef ? "Take a new snapshot to get fresh refs, or use targetSelector for elements not in the accessibility tree." : void 0);
+			await sourceLocator.dragTo(targetLocator, { timeout: this.defaultTimeout });
+			return {
+				success: true,
+				url: page.url(),
+				hint: "Drag complete. Take a snapshot to see the result."
+			};
+		} catch (error) {
+			return this.createErrorFromException(error, "Drag");
+		}
+	}
+	async evaluate(input, threadId) {
+		try {
+			return {
+				success: true,
+				result: await (await this.getPage(threadId)).evaluate(input.script),
+				hint: "JavaScript executed. Take a snapshot if the page may have changed."
+			};
+		} catch (error) {
+			return this.createErrorFromException(error, "Evaluate");
+		}
+	}
+	async closeBrowser() {
+		try {
+			await this.close();
+			return {
+				success: true,
+				hint: "Browser closed. Call browser_goto to start a new session."
+			};
+		} catch (error) {
+			return this.createErrorFromException(error, "Close");
+		}
+	}
+	async startScreencast(_options) {
+		const requestedThreadId = _options?.threadId;
+		const effectiveThreadId = this.getScope() === "thread" ? requestedThreadId ?? this.getCurrentThread() ?? DEFAULT_THREAD_ID : requestedThreadId;
+		let browserManager;
+		if (this.getScope() === "thread") browserManager = await this.getManagerForThread(effectiveThreadId);
+		else {
+			if (!this.sharedManager) throw new Error("Browser not launched");
+			browserManager = this.sharedManager;
+		}
+		const stream = new ScreencastStreamImpl({
+			getCdpSession: async () => {
+				const currentPage = browserManager.getPage();
+				if (!currentPage) throw new Error("No active page available");
+				return await currentPage.context().newCDPSession(currentPage);
+			},
+			isBrowserRunning: () => browserManager.isLaunched()
+		}, _options);
+		const streamKey = this.getStreamKey(effectiveThreadId);
+		this.activeScreencastStreams.set(streamKey, stream);
+		const context = browserManager.getContext();
+		if (context) {
+			const onNewPage = (_newPage) => {
+				setTimeout(() => {
+					if (stream.isActive()) stream.reconnect().catch(() => {});
+				}, 100);
+			};
+			context.on("page", onNewPage);
+			const pageCloseHandlers = /* @__PURE__ */ new Map();
+			const frameNavigatedHandlers = /* @__PURE__ */ new Map();
+			const setupPageListeners = (page) => {
+				const onFrameNavigated = (frame) => {
+					if (!frame.parentFrame()) {
+						stream.emitUrl(frame.url());
+						this.updateSessionBrowserState(effectiveThreadId);
+					}
+				};
+				page.on("framenavigated", onFrameNavigated);
+				frameNavigatedHandlers.set(page, onFrameNavigated);
+				const onClose = () => {
+					pageCloseHandlers.delete(page);
+					const navHandler = frameNavigatedHandlers.get(page);
+					if (navHandler) {
+						page.off("framenavigated", navHandler);
+						frameNavigatedHandlers.delete(page);
+					}
+					setTimeout(() => {
+						const remainingPages = browserManager.getPages();
+						if (stream.isActive() && remainingPages.length > 0) {
+							stream.reconnect().catch(() => {});
+							const activePage = remainingPages[browserManager.getActiveIndex()] || remainingPages[0];
+							if (activePage) {
+								const url = activePage.url();
+								if (url && url !== "about:blank") stream.emitUrl(url);
+							}
+						}
+					}, 100);
+				};
+				page.once("close", onClose);
+				pageCloseHandlers.set(page, onClose);
+			};
+			const setupPageCloseListener = setupPageListeners;
+			for (const page of browserManager.getPages()) setupPageCloseListener(page);
+			const onNewPageWithCloseListener = (newPage) => {
+				setupPageCloseListener(newPage);
+				const url = newPage.url();
+				if (url && url !== "about:blank") stream.emitUrl(url);
+				onNewPage(newPage);
+			};
+			context.off("page", onNewPage);
+			context.on("page", onNewPageWithCloseListener);
+			stream.once("stop", () => {
+				context.off("page", onNewPageWithCloseListener);
+				for (const [page, handler] of pageCloseHandlers) page.off("close", handler);
+				pageCloseHandlers.clear();
+				for (const [page, handler] of frameNavigatedHandlers) page.off("framenavigated", handler);
+				frameNavigatedHandlers.clear();
+				this.activeScreencastStreams.delete(streamKey);
+			});
+		}
+		await stream.start();
+		return stream;
+	}
+	async injectMouseEvent(event, threadId) {
+		const effectiveThreadId = threadId ?? this.getCurrentThread();
+		await (await this.getManagerForThread(effectiveThreadId)).injectMouseEvent(event);
+	}
+	async injectKeyboardEvent(event, threadId) {
+		const effectiveThreadId = threadId ?? this.getCurrentThread();
+		await (await (await this.getManagerForThread(effectiveThreadId)).getCDPSession()).send("Input.dispatchKeyEvent", {
+			type: event.type,
+			key: event.key,
+			code: event.code,
+			text: event.text,
+			modifiers: event.modifiers ?? 0,
+			windowsVirtualKeyCode: event.windowsVirtualKeyCode
+		});
+	}
 };
-
+//#endregion
 export { AgentBrowser, AgentBrowserThreadManager, BROWSER_TOOLS, backInputSchema, browserSchemas, clickInputSchema, closeInputSchema, createAgentBrowserTools, dialogInputSchema, dragInputSchema, evaluateInputSchema, getBrowserPid, gotoInputSchema, hoverInputSchema, pressInputSchema, scrollInputSchema, selectInputSchema, snapshotInputSchema, tabsInputSchema, typeInputSchema, waitInputSchema };
-//# sourceMappingURL=index.js.map
+
 //# sourceMappingURL=index.js.map