@mastra/stagehand 0.3.1 → 0.3.2-alpha.0

package/dist/index.d.cts

@@ -1,53 +1,46 @@
-import { Stagehand, ModelConfiguration as ModelConfiguration$1 } from '@browserbasehq/stagehand';
-import { ThreadManager, ThreadSession, ThreadManagerConfig, BrowserConfig, BrowserRecordingOptions, MastraBrowser, BrowserToolError, BrowserState, BrowserTabState, ScreencastOptions, ScreencastStream, MouseEventParams, KeyboardEventParams } from '@mastra/core/browser';
-import { Tool } from '@mastra/core/tools';
-import { z } from 'zod';
-
-/**
- * Stagehand Tool Schemas
- *
- * AI-powered browser tools using natural language instructions.
- * These are fundamentally different from the deterministic AgentBrowser tools.
- */
-
+import { ModelConfiguration as ModelConfiguration$1, Stagehand } from "@browserbasehq/stagehand";
+import { BrowserConfig, BrowserRecordingOptions, BrowserState, BrowserTabState, BrowserToolError, KeyboardEventParams, MastraBrowser, MouseEventParams, ScreencastOptions, ScreencastStream, ThreadManager, ThreadManagerConfig, ThreadSession } from "@mastra/core/browser";
+import { Tool } from "@mastra/core/tools";
+import { z } from "zod";
+//#region src/schemas.d.ts
 /**
  * stagehand_act - Perform an action using natural language
  */
 declare const actInputSchema: z.ZodObject<{
-    instruction: z.ZodString;
-    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    useVision: z.ZodOptional<z.ZodBoolean>;
-    timeout: z.ZodOptional<z.ZodNumber>;
+  instruction: z.ZodString;
+  variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  useVision: z.ZodOptional<z.ZodBoolean>;
+  timeout: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 type ActInput = z.output<typeof actInputSchema>;
 /**
  * stagehand_extract - Extract structured data from a page
  */
 declare const extractInputSchema: z.ZodObject<{
-    instruction: z.ZodString;
-    schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    timeout: z.ZodOptional<z.ZodNumber>;
+  instruction: z.ZodString;
+  schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  timeout: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 type ExtractInput = z.output<typeof extractInputSchema>;
 /**
  * stagehand_observe - Discover actionable elements on a page
  */
 declare const observeInputSchema: z.ZodObject<{
-    instruction: z.ZodOptional<z.ZodString>;
-    onlyVisible: z.ZodOptional<z.ZodBoolean>;
-    timeout: z.ZodOptional<z.ZodNumber>;
+  instruction: z.ZodOptional<z.ZodString>;
+  onlyVisible: z.ZodOptional<z.ZodBoolean>;
+  timeout: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 type ObserveInput = z.output<typeof observeInputSchema>;
 /**
  * stagehand_navigate - Navigate to a URL
  */
 declare const navigateInputSchema: z.ZodObject<{
-    url: z.ZodString;
-    waitUntil: z.ZodOptional<z.ZodEnum<{
-        load: "load";
-        domcontentloaded: "domcontentloaded";
-        networkidle: "networkidle";
-    }>>;
+  url: z.ZodString;
+  waitUntil: z.ZodOptional<z.ZodEnum<{
+    load: "load";
+    domcontentloaded: "domcontentloaded";
+    networkidle: "networkidle";
+  }>>;
 }, z.core.$strip>;
 type NavigateInput = z.output<typeof navigateInputSchema>;
 /**
@@ -59,91 +52,82 @@ type CloseInput = z.output<typeof closeInputSchema>;
  * stagehand_tabs - Manage browser tabs
  */
 declare const tabsInputSchema: z.ZodObject<{
-    action: z.ZodEnum<{
-        list: "list";
-        new: "new";
-        switch: "switch";
-        close: "close";
-    }>;
-    index: z.ZodOptional<z.ZodNumber>;
-    url: z.ZodOptional<z.ZodString>;
+  action: z.ZodEnum<{
+    list: "list";
+    new: "new";
+    switch: "switch";
+    close: "close";
+  }>;
+  index: z.ZodOptional<z.ZodNumber>;
+  url: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type TabsInput = z.output<typeof tabsInputSchema>;
 /**
  * stagehand_screenshot - Capture a screenshot of the current page
  */
 declare const screenshotInputSchema: z.ZodObject<{
-    fullPage: z.ZodOptional<z.ZodBoolean>;
+  fullPage: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type ScreenshotInput = z.output<typeof screenshotInputSchema>;
 declare const stagehandSchemas: {
-    readonly act: z.ZodObject<{
-        instruction: z.ZodString;
-        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        useVision: z.ZodOptional<z.ZodBoolean>;
-        timeout: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
-    readonly extract: z.ZodObject<{
-        instruction: z.ZodString;
-        schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        timeout: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
-    readonly observe: z.ZodObject<{
-        instruction: z.ZodOptional<z.ZodString>;
-        onlyVisible: z.ZodOptional<z.ZodBoolean>;
-        timeout: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
-    readonly navigate: z.ZodObject<{
-        url: z.ZodString;
-        waitUntil: z.ZodOptional<z.ZodEnum<{
-            load: "load";
-            domcontentloaded: "domcontentloaded";
-            networkidle: "networkidle";
-        }>>;
-    }, z.core.$strip>;
-    readonly tabs: z.ZodObject<{
-        action: z.ZodEnum<{
-            list: "list";
-            new: "new";
-            switch: "switch";
-            close: "close";
-        }>;
-        index: z.ZodOptional<z.ZodNumber>;
-        url: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    readonly close: z.ZodObject<{}, z.core.$strip>;
-    readonly screenshot: z.ZodObject<{
-        fullPage: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>;
+  readonly act: z.ZodObject<{
+    instruction: z.ZodString;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    useVision: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+  readonly extract: z.ZodObject<{
+    instruction: z.ZodString;
+    schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+  readonly observe: z.ZodObject<{
+    instruction: z.ZodOptional<z.ZodString>;
+    onlyVisible: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+  readonly navigate: z.ZodObject<{
+    url: z.ZodString;
+    waitUntil: z.ZodOptional<z.ZodEnum<{
+      load: "load";
+      domcontentloaded: "domcontentloaded";
+      networkidle: "networkidle";
+    }>>;
+  }, z.core.$strip>;
+  readonly tabs: z.ZodObject<{
+    action: z.ZodEnum<{
+      list: "list";
+      new: "new";
+      switch: "switch";
+      close: "close";
+    }>;
+    index: z.ZodOptional<z.ZodNumber>;
+    url: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  readonly close: z.ZodObject<{}, z.core.$strip>;
+  readonly screenshot: z.ZodObject<{
+    fullPage: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>;
 };
-
-/**
- * StagehandThreadManager - Thread scope management for StagehandBrowser
- *
- * Supports two scope modes:
- * - 'shared': All threads share the same Stagehand instance and page
- * - 'thread': Each thread gets its own Stagehand instance (separate browser)
- *
- * @see AgentBrowserThreadManager for the equivalent implementation.
- */
-
+//#endregion
+//#region src/thread-manager.d.ts
 type V3 = Stagehand;
 type V3Page$1 = NonNullable<ReturnType<NonNullable<Stagehand['context']>['activePage']>>;
 /**
  * Extended session info for Stagehand threads.
  */
 interface StagehandThreadSession extends ThreadSession {
-    /** For 'thread' mode: dedicated Stagehand instance */
-    stagehand?: V3;
+  /** For 'thread' mode: dedicated Stagehand instance */
+  stagehand?: V3;
 }
 /**
  * Configuration for StagehandThreadManager.
  */
 interface StagehandThreadManagerConfig extends ThreadManagerConfig {
-    /** Function to create a new Stagehand instance (for 'thread' mode) */
-    createStagehand?: () => Promise<V3>;
-    /** Callback when a new browser/Stagehand instance is created for a thread */
-    onBrowserCreated?: (stagehand: V3, threadId: string) => void;
+  /** Function to create a new Stagehand instance (for 'thread' mode) */
+  createStagehand?: () => Promise<V3>;
+  /** Callback when a new browser/Stagehand instance is created for a thread */
+  onBrowserCreated?: (stagehand: V3, threadId: string) => void;
 }
 /**
  * Thread manager for StagehandBrowser.
@@ -153,169 +137,177 @@ interface StagehandThreadManagerConfig extends ThreadManagerConfig {
  * - 'thread': Each thread gets a dedicated Stagehand instance
  */
 declare class StagehandThreadManager extends ThreadManager<V3> {
-    protected sessions: Map<string, StagehandThreadSession>;
-    private createStagehand?;
-    private onBrowserCreated?;
-    constructor(config: StagehandThreadManagerConfig);
-    /**
-     * Set the factory function for creating new Stagehand instances.
-     * Required for 'thread' scope mode.
-     */
-    setCreateStagehand(factory: () => Promise<V3>): void;
-    /**
-     * Get the page for a specific thread, creating session if needed.
-     */
-    getPageForThread(threadId?: string): Promise<V3Page$1 | null>;
-    /**
-     * Create a new session for a thread.
-     */
-    protected createSession(threadId: string): Promise<StagehandThreadSession>;
-    /**
-     * Restore browser state (multiple tabs) to a Stagehand instance.
-     */
-    private restoreBrowserState;
-    /**
-     * Get the manager (Stagehand instance) for a specific session.
-     */
-    protected getManagerForSession(session: StagehandThreadSession): V3;
-    /**
-     * Destroy a session and clean up resources.
-     */
-    protected doDestroySession(session: StagehandThreadSession): Promise<void>;
-    /**
-     * Destroy all sessions (called during browser close).
-     * doDestroySession handles closing individual Stagehand instances.
-     */
-    destroyAllSessions(): Promise<void>;
+  protected sessions: Map<string, StagehandThreadSession>;
+  private createStagehand?;
+  private onBrowserCreated?;
+  constructor(config: StagehandThreadManagerConfig);
+  /**
+   * Set the factory function for creating new Stagehand instances.
+   * Required for 'thread' scope mode.
+   */
+  setCreateStagehand(factory: () => Promise<V3>): void;
+  /**
+   * Get the page for a specific thread, creating session if needed.
+   */
+  getPageForThread(threadId?: string): Promise<V3Page$1 | null>;
+  /**
+   * Create a new session for a thread.
+   */
+  protected createSession(threadId: string): Promise<StagehandThreadSession>;
+  /**
+   * Restore browser state (multiple tabs) to a Stagehand instance.
+   */
+  private restoreBrowserState;
+  /**
+   * Get the manager (Stagehand instance) for a specific session.
+   */
+  protected getManagerForSession(session: StagehandThreadSession): V3;
+  /**
+   * Destroy a session and clean up resources.
+   */
+  protected doDestroySession(session: StagehandThreadSession): Promise<void>;
+  /**
+   * Destroy all sessions (called during browser close).
+   * doDestroySession handles closing individual Stagehand instances.
+   */
+  destroyAllSessions(): Promise<void>;
 }
-
+//#endregion
+//#region src/tools/constants.d.ts
 /**
  * Stagehand Tool Constants
  */
 declare const STAGEHAND_TOOLS: {
-    readonly ACT: "stagehand_act";
-    readonly EXTRACT: "stagehand_extract";
-    readonly OBSERVE: "stagehand_observe";
-    readonly NAVIGATE: "stagehand_navigate";
-    readonly TABS: "stagehand_tabs";
-    readonly CLOSE: "stagehand_close";
-    readonly SCREENSHOT: "stagehand_screenshot";
+  readonly ACT: "stagehand_act";
+  readonly EXTRACT: "stagehand_extract";
+  readonly OBSERVE: "stagehand_observe";
+  readonly NAVIGATE: "stagehand_navigate";
+  readonly TABS: "stagehand_tabs";
+  readonly CLOSE: "stagehand_close";
+  readonly SCREENSHOT: "stagehand_screenshot";
 };
 type StagehandToolName = (typeof STAGEHAND_TOOLS)[keyof typeof STAGEHAND_TOOLS];
-
-/**
- * Stagehand Browser Types
- */
-
+//#endregion
+//#region src/types.d.ts
 /**
  * Model configuration for Stagehand AI operations.
  */
 type ModelConfiguration = ModelConfiguration$1;
+/**
+ * Providers Stagehand can resolve from a `provider/model` string.
+ *
+ * Stagehand splits the model id on its first slash and looks the prefix up in
+ * its internal AI SDK provider registry; an unknown prefix throws during
+ * browser startup rather than at configuration time. Mirrored here so callers
+ * can reject a bad provider up front. Keep in sync with `AISDKProviders` in
+ * `@browserbasehq/stagehand`.
+ */
+declare const STAGEHAND_MODEL_PROVIDERS: readonly ["anthropic", "azure", "bedrock", "cerebras", "deepseek", "gateway", "google", "groq", "mistral", "ollama", "openai", "perplexity", "togetherai", "vertex", "xai"];
 /**
  * Stagehand-specific configuration fields.
  */
 interface StagehandLogLine {
-    category?: string;
-    message: string;
-    level?: 0 | 1 | 2;
-    timestamp?: string;
-    auxiliary?: Record<string, {
-        value: string;
-        type: string;
-    }>;
+  category?: string;
+  message: string;
+  level?: 0 | 1 | 2;
+  timestamp?: string;
+  auxiliary?: Record<string, {
+    value: string;
+    type: string;
+  }>;
 }
 interface StagehandConfigExtensions {
-    /**
-     * Environment to run the browser in
-     * - 'LOCAL': Run browser locally
-     * - 'BROWSERBASE': Use Browserbase cloud
-     * @default 'LOCAL'
-     */
-    env?: 'LOCAL' | 'BROWSERBASE';
-    /**
-     * Browserbase API key (required when env = 'BROWSERBASE')
-     */
-    apiKey?: string;
-    /**
-     * Browserbase project ID (required when env = 'BROWSERBASE')
-     */
-    projectId?: string;
-    /**
-     * Model configuration for AI operations
-     * @default 'openai/gpt-4o'
-     */
-    model?: ModelConfiguration;
-    /**
-     * Enable Stagehand experimental features.
-     */
-    experimental?: boolean;
-    /**
-     * Disable the Stagehand API so model execution runs locally.
-     */
-    disableAPI?: boolean;
-    /**
-     * Enable self-healing selectors.
-     * When enabled, Stagehand uses AI to find elements even when selectors fail.
-     * @default true
-     */
-    selfHeal?: boolean;
-    /**
-     * Timeout for DOM to settle after actions (ms)
-     * @default 5000
-     */
-    domSettleTimeout?: number;
-    /**
-     * Logging verbosity level.
-     * - 0: Suppress INFO/DEBUG logs
-     * - 1: Include INFO logs
-     * - 2: Include DEBUG logs
-     *
-     * @default 0
-     */
-    verbose?: 0 | 1 | 2;
-    /**
-     * Optional Stagehand logger hook. When provided, Stagehand log lines are
-     * routed here instead of being written directly to the process console.
-     */
-    logger?: (line: StagehandLogLine) => void;
-    /**
-     * Disable Stagehand's Pino console logging backend.
-     *
-     * @default true
-     */
-    disablePino?: boolean;
-    /**
-     * Custom system prompt for AI operations (act, extract, observe)
-     */
-    systemPrompt?: string;
-    /**
-     * Whether to preserve the user data directory after the browser closes.
-     * By default, Stagehand may clean up temporary user data directories.
-     * Set to `true` to keep the profile data for future sessions.
-     *
-     * Only applicable when `profile` is provided.
-     *
-     * @default false
-     */
-    preserveUserDataDir?: boolean;
-    /**
-     * Alpha: opt into browser recording tools.
-     *
-     * Recording tools are disabled by default. Provide an output directory to add
-     * `browser_record` and `browser_record_caption` to this browser's toolset.
-     */
-    recording?: BrowserRecordingOptions;
-    /**
-     * Tool names to exclude from the browser toolset.
-     * Use this to disable specific tools, e.g. `['stagehand_screenshot']`
-     * to skip the screenshot tool for models that don't support vision.
-     *
-     * @example
-     * ```ts
-     * new StagehandBrowser({ excludeTools: ['stagehand_screenshot'] })
-     * ```
-     */
-    excludeTools?: StagehandToolName[];
+  /**
+   * Environment to run the browser in
+   * - 'LOCAL': Run browser locally
+   * - 'BROWSERBASE': Use Browserbase cloud
+   * @default 'LOCAL'
+   */
+  env?: 'LOCAL' | 'BROWSERBASE';
+  /**
+   * Browserbase API key (required when env = 'BROWSERBASE')
+   */
+  apiKey?: string;
+  /**
+   * Browserbase project ID (required when env = 'BROWSERBASE')
+   */
+  projectId?: string;
+  /**
+   * Model configuration for AI operations
+   * @default 'openai/gpt-4o'
+   */
+  model?: ModelConfiguration;
+  /**
+   * Enable Stagehand experimental features.
+   */
+  experimental?: boolean;
+  /**
+   * Disable the Stagehand API so model execution runs locally.
+   */
+  disableAPI?: boolean;
+  /**
+   * Enable self-healing selectors.
+   * When enabled, Stagehand uses AI to find elements even when selectors fail.
+   * @default true
+   */
+  selfHeal?: boolean;
+  /**
+   * Timeout for DOM to settle after actions (ms)
+   * @default 5000
+   */
+  domSettleTimeout?: number;
+  /**
+   * Logging verbosity level.
+   * - 0: Suppress INFO/DEBUG logs
+   * - 1: Include INFO logs
+   * - 2: Include DEBUG logs
+   *
+   * @default 0
+   */
+  verbose?: 0 | 1 | 2;
+  /**
+   * Optional Stagehand logger hook. When provided, Stagehand log lines are
+   * routed here instead of being written directly to the process console.
+   */
+  logger?: (line: StagehandLogLine) => void;
+  /**
+   * Disable Stagehand's Pino console logging backend.
+   *
+   * @default true
+   */
+  disablePino?: boolean;
+  /**
+   * Custom system prompt for AI operations (act, extract, observe)
+   */
+  systemPrompt?: string;
+  /**
+   * Whether to preserve the user data directory after the browser closes.
+   * By default, Stagehand may clean up temporary user data directories.
+   * Set to `true` to keep the profile data for future sessions.
+   *
+   * Only applicable when `profile` is provided.
+   *
+   * @default false
+   */
+  preserveUserDataDir?: boolean;
+  /**
+   * Alpha: opt into browser recording tools.
+   *
+   * Recording tools are disabled by default. Provide an output directory to add
+   * `browser_record` and `browser_record_caption` to this browser's toolset.
+   */
+  recording?: BrowserRecordingOptions;
+  /**
+   * Tool names to exclude from the browser toolset.
+   * Use this to disable specific tools, e.g. `['stagehand_screenshot']`
+   * to skip the screenshot tool for models that don't support vision.
+   *
+   * @example
+   * ```ts
+   * new StagehandBrowser({ excludeTools: ['stagehand_screenshot'] })
+   * ```
+   */
+  excludeTools?: StagehandToolName[];
 }
 /**
  * Configuration for StagehandBrowser.
@@ -326,54 +318,46 @@ type StagehandBrowserConfig = BrowserConfig & StagehandConfigExtensions;
  * Action returned from observe()
  */
 interface StagehandAction {
-    /** XPath selector to locate element */
-    selector: string;
-    /** Human-readable description */
-    description: string;
-    /** Suggested action method */
-    method?: string;
-    /** Additional action parameters */
-    arguments?: string[];
+  /** XPath selector to locate element */
+  selector: string;
+  /** Human-readable description */
+  description: string;
+  /** Suggested action method */
+  method?: string;
+  /** Additional action parameters */
+  arguments?: string[];
 }
 /**
  * Result from act()
  */
 interface ActResult {
-    success: boolean;
-    message?: string;
-    action?: string;
-    url?: string;
-    hint?: string;
+  success: boolean;
+  message?: string;
+  action?: string;
+  url?: string;
+  hint?: string;
 }
 /**
  * Result from extract()
  */
 interface ExtractResult<T = unknown> {
-    success: boolean;
-    data?: T;
-    error?: string;
-    url?: string;
-    hint?: string;
+  success: boolean;
+  data?: T;
+  error?: string;
+  url?: string;
+  hint?: string;
 }
 /**
  * Result from observe()
  */
 interface ObserveResult {
-    success: boolean;
-    actions: StagehandAction[];
-    url?: string;
-    hint?: string;
+  success: boolean;
+  actions: StagehandAction[];
+  url?: string;
+  hint?: string;
 }
-
-/**
- * StagehandBrowser - AI-powered browser automation using Stagehand v3
- *
- * Uses natural language instructions for browser interactions.
- * Fundamentally different from AgentBrowser's deterministic refs approach.
- *
- * Stagehand v3 is CDP-native and provides direct CDP access for screencast/input injection.
- */
-
+//#endregion
+//#region src/stagehand-browser.d.ts
 type V3Page = NonNullable<ReturnType<NonNullable<Stagehand['context']>['activePage']>>;
 /**
  * StagehandBrowser - AI-powered browser using Stagehand v3
@@ -386,202 +370,203 @@ type V3Page = NonNullable<ReturnType<NonNullable<Stagehand['context']>['activePa
  * - 'thread': Each thread gets its own Stagehand instance (separate browser)
  */
 declare class StagehandBrowser extends MastraBrowser {
-    readonly id: string;
-    readonly name = "StagehandBrowser";
-    readonly provider = "browserbase/stagehand";
-    /** Shared Stagehand instance (for 'shared' scope) - narrowed type from base class */
-    protected sharedManager: Stagehand | null;
-    private stagehandConfig;
-    /** Thread manager - narrowed type from base class */
-    protected threadManager: StagehandThreadManager;
-    /** Debounce timers per thread for tab change reconnection */
-    private tabChangeDebounceTimers;
-    constructor(config?: StagehandBrowserConfig);
-    /**
-     * Ensure browser is ready and thread session exists.
-     * For 'thread' scope, this creates a dedicated Stagehand instance for the thread.
-     */
-    ensureReady(): Promise<void>;
-    /**
-     * Build Stagehand options from config.
-     * Returns the configuration object expected by Stagehand constructor.
-     */
-    private buildStagehandOptions;
-    /**
-     * Create a new Stagehand instance with the current config.
-     * Used by thread manager for 'thread' scope.
-     */
-    private createStagehandInstance;
-    protected doLaunch(): Promise<void>;
-    /**
-     * Set up close event listener for a shared Stagehand instance.
-     * Listens to both context and page close events for robust detection.
-     */
-    /**
-     * Set up a CDP-based close listener for a Stagehand instance.
-     *
-     * Tracks page targets via CDP `Target.targetCreated` / `Target.targetDestroyed`.
-     * When all page targets are gone the `onDisconnect` callback fires. This is more
-     * reliable than Playwright's `context.close` / `page.close` events which don't
-     * fire when Chrome is killed externally (SIGTERM/SIGKILL).
-     */
-    private setupCloseListener;
-    protected doClose(): Promise<void>;
-    handleBrowserDisconnected(): void;
-    protected handleThreadBrowserDisconnected(threadId: string): void;
-    closeThreadSession(threadId: string): Promise<void>;
-    private patchExitType;
-    /**
-     * Check if the browser is still alive by verifying the context and pages exist.
-     * Called by base class ensureReady() to detect externally closed browsers.
-     */
-    protected checkBrowserAlive(): Promise<boolean>;
-    /**
-     * Create an error response from an exception.
-     * Extends base class to add Stagehand-specific error handling.
-     */
-    protected createErrorFromException(error: unknown, context: string): BrowserToolError;
-    /**
-     * Get the Stagehand instance for a thread, creating it if needed.
-     * For 'thread' scope, this creates a dedicated Stagehand instance.
-     * For 'shared' scope, returns the shared instance.
-     */
-    getManagerForThread(threadId?: string): Promise<Stagehand | null>;
-    /**
-     * Require a Stagehand instance for the given or current thread.
-     * Throws if no instance is available.
-     * @param explicitThreadId - Optional thread ID to use instead of getCurrentThread()
-     *                           Use this to avoid race conditions in concurrent tool calls.
-     */
-    private requireStagehand;
-    /**
-     * Get the current page from Stagehand v3, respecting thread scope.
-     * @param explicitThreadId - Optional thread ID to use instead of getCurrentThread()
-     *                           Use this to avoid race conditions in concurrent tool calls.
-     */
-    private getPage;
-    /**
-     * Get the active page for a thread (implements abstract method from base class).
-     */
-    protected getActivePage(threadId?: string): Promise<V3Page | null>;
-    /**
-     * Get a CDP session for a specific page.
-     */
-    private getCdpSessionForPage;
-    getTools(): Record<string, Tool<any, any>>;
-    /**
-     * Perform an action using natural language instruction
-     * @param input - Action input
-     * @param threadId - Optional thread ID for thread-safe operation
-     */
-    act(input: ActInput, threadId?: string): Promise<{
-        success: true;
-        message?: string;
-        action?: string;
-        url: string;
-        hint: string;
-    } | BrowserToolError>;
-    /**
-     * Extract structured data from a page using natural language
-     * @param input - Extract input
-     * @param threadId - Optional thread ID for thread-safe operation
-     */
-    extract(input: ExtractInput, threadId?: string): Promise<{
-        success: true;
-        data: unknown;
-        url: string;
-        hint: string;
-    } | BrowserToolError>;
-    /**
-     * Discover actionable elements on a page
-     * @param input - Observe input
-     * @param threadId - Optional thread ID for thread-safe operation
-     */
-    observe(input: ObserveInput, threadId?: string): Promise<{
-        success: true;
-        actions: StagehandAction[];
-        url: string;
-        hint: string;
-    } | BrowserToolError>;
-    /**
-     * Navigate to a URL
-     * @param input - Navigate input
-     * @param threadId - Optional thread ID for thread-safe operation
-     */
-    navigate(input: NavigateInput, threadId?: string): Promise<{
-        success: true;
-        url: string;
-        title: string;
-        hint: string;
-    } | BrowserToolError>;
-    /**
-     * Capture a screenshot of the current page
-     * @param input - Screenshot input
-     * @param threadId - Optional thread ID for thread-safe operation
-     */
-    screenshot(input: ScreenshotInput, threadId?: string): Promise<{
-        base64: string;
-        url: string;
-        title: string;
-    } | BrowserToolError>;
-    /**
-     * Manage browser tabs - list, create, switch, close
-     * @param input - Tabs input
-     * @param threadId - Optional thread ID for thread-safe operation
-     */
-    tabs(input: TabsInput, threadId?: string): Promise<{
-        success: true;
-        tabs?: Array<{
-            index: number;
-            url: string;
-            title: string;
-            active: boolean;
-        }>;
-        hint: string;
-    } | {
-        success: true;
-        index?: number;
-        url?: string;
-        title?: string;
-        remaining?: number;
-        hint: string;
-    } | BrowserToolError>;
-    getCurrentUrl(threadId?: string): Promise<string | null>;
-    /**
-     * Navigate to a URL (simple version). Used internally for restoring state on relaunch.
-     */
-    navigateTo(url: string): Promise<void>;
-    /**
-     * Get the current browser state (all tabs and active tab index).
-     */
-    getBrowserState(threadId?: string): Promise<BrowserState | null>;
-    /**
-     * Get browser state for a thread (implements abstract method from base class).
-     * Sync version that uses existing manager lookup without creating sessions.
-     */
-    protected getBrowserStateForThread(threadId?: string): BrowserState | null;
-    /**
-     * Get browser state from a specific Stagehand instance.
-     */
-    private getBrowserStateFromStagehand;
-    /**
-     * Get all open tabs with their URLs and titles.
-     */
-    getTabState(threadId?: string): Promise<BrowserTabState[]>;
-    /**
-     * Get the active tab index.
-     */
-    getActiveTabIndex(threadId?: string): Promise<number>;
-    startScreencast(options?: ScreencastOptions): Promise<ScreencastStream>;
-    /**
-     * Set up listeners to detect tab changes and reconnect the screencast.
-     * Uses CDP Target events since Stagehand doesn't expose page lifecycle events.
-     */
-    private setupTabChangeDetection;
-    injectMouseEvent(event: MouseEventParams, threadId?: string): Promise<void>;
-    injectKeyboardEvent(event: KeyboardEventParams, threadId?: string): Promise<void>;
+  readonly id: string;
+  readonly name = "StagehandBrowser";
+  readonly provider = "browserbase/stagehand";
+  /** Shared Stagehand instance (for 'shared' scope) - narrowed type from base class */
+  protected sharedManager: Stagehand | null;
+  private stagehandConfig;
+  /** Thread manager - narrowed type from base class */
+  protected threadManager: StagehandThreadManager;
+  /** Debounce timers per thread for tab change reconnection */
+  private tabChangeDebounceTimers;
+  constructor(config?: StagehandBrowserConfig);
+  /**
+   * Ensure browser is ready and thread session exists.
+   * For 'thread' scope, this creates a dedicated Stagehand instance for the thread.
+   */
+  ensureReady(): Promise<void>;
+  /**
+   * Build Stagehand options from config.
+   * Returns the configuration object expected by Stagehand constructor.
+   */
+  private buildStagehandOptions;
+  /**
+   * Create a new Stagehand instance with the current config.
+   * Used by thread manager for 'thread' scope.
+   */
+  private createStagehandInstance;
+  protected doLaunch(): Promise<void>;
+  /**
+   * Set up close event listener for a shared Stagehand instance.
+   * Listens to both context and page close events for robust detection.
+   */
+  /**
+   * Set up a CDP-based close listener for a Stagehand instance.
+   *
+   * Tracks page targets via CDP `Target.targetCreated` / `Target.targetDestroyed`.
+   * When all page targets are gone the `onDisconnect` callback fires. This is more
+   * reliable than Playwright's `context.close` / `page.close` events which don't
+   * fire when Chrome is killed externally (SIGTERM/SIGKILL).
+   */
+  private setupCloseListener;
+  protected doClose(): Promise<void>;
+  handleBrowserDisconnected(): void;
+  protected handleThreadBrowserDisconnected(threadId: string): void;
+  closeThreadSession(threadId: string): Promise<void>;
+  private patchExitType;
+  /**
+   * Check if the browser is still alive by verifying the context and pages exist.
+   * Called by base class ensureReady() to detect externally closed browsers.
+   */
+  protected checkBrowserAlive(): Promise<boolean>;
+  /**
+   * Create an error response from an exception.
+   * Extends base class to add Stagehand-specific error handling.
+   */
+  protected createErrorFromException(error: unknown, context: string): BrowserToolError;
+  /**
+   * Get the Stagehand instance for a thread, creating it if needed.
+   * For 'thread' scope, this creates a dedicated Stagehand instance.
+   * For 'shared' scope, returns the shared instance.
+   */
+  getManagerForThread(threadId?: string): Promise<Stagehand | null>;
+  /**
+   * Require a Stagehand instance for the given or current thread.
+   * Throws if no instance is available.
+   * @param explicitThreadId - Optional thread ID to use instead of getCurrentThread()
+   *                           Use this to avoid race conditions in concurrent tool calls.
+   */
+  private requireStagehand;
+  /**
+   * Get the current page from Stagehand v3, respecting thread scope.
+   * @param explicitThreadId - Optional thread ID to use instead of getCurrentThread()
+   *                           Use this to avoid race conditions in concurrent tool calls.
+   */
+  private getPage;
+  /**
+   * Get the active page for a thread (implements abstract method from base class).
+   */
+  protected getActivePage(threadId?: string): Promise<V3Page | null>;
+  /**
+   * Get a CDP session for a specific page.
+   */
+  private getCdpSessionForPage;
+  getTools(): Record<string, Tool<any, any>>;
+  /**
+   * Perform an action using natural language instruction
+   * @param input - Action input
+   * @param threadId - Optional thread ID for thread-safe operation
+   */
+  act(input: ActInput, threadId?: string): Promise<{
+    success: true;
+    message?: string;
+    action?: string;
+    url: string;
+    hint: string;
+  } | BrowserToolError>;
+  /**
+   * Extract structured data from a page using natural language
+   * @param input - Extract input
+   * @param threadId - Optional thread ID for thread-safe operation
+   */
+  extract(input: ExtractInput, threadId?: string): Promise<{
+    success: true;
+    data: unknown;
+    url: string;
+    hint: string;
+  } | BrowserToolError>;
+  /**
+   * Discover actionable elements on a page
+   * @param input - Observe input
+   * @param threadId - Optional thread ID for thread-safe operation
+   */
+  observe(input: ObserveInput, threadId?: string): Promise<{
+    success: true;
+    actions: StagehandAction[];
+    url: string;
+    hint: string;
+  } | BrowserToolError>;
+  /**
+   * Navigate to a URL
+   * @param input - Navigate input
+   * @param threadId - Optional thread ID for thread-safe operation
+   */
+  navigate(input: NavigateInput, threadId?: string): Promise<{
+    success: true;
+    url: string;
+    title: string;
+    hint: string;
+  } | BrowserToolError>;
+  /**
+   * Capture a screenshot of the current page
+   * @param input - Screenshot input
+   * @param threadId - Optional thread ID for thread-safe operation
+   */
+  screenshot(input: ScreenshotInput, threadId?: string): Promise<{
+    base64: string;
+    url: string;
+    title: string;
+  } | BrowserToolError>;
+  /**
+   * Manage browser tabs - list, create, switch, close
+   * @param input - Tabs input
+   * @param threadId - Optional thread ID for thread-safe operation
+   */
+  tabs(input: TabsInput, threadId?: string): Promise<{
+    success: true;
+    tabs?: Array<{
+      index: number;
+      url: string;
+      title: string;
+      active: boolean;
+    }>;
+    hint: string;
+  } | {
+    success: true;
+    index?: number;
+    url?: string;
+    title?: string;
+    remaining?: number;
+    hint: string;
+  } | BrowserToolError>;
+  getCurrentUrl(threadId?: string): Promise<string | null>;
+  /**
+   * Navigate to a URL (simple version). Used internally for restoring state on relaunch.
+   */
+  navigateTo(url: string): Promise<void>;
+  /**
+   * Get the current browser state (all tabs and active tab index).
+   */
+  getBrowserState(threadId?: string): Promise<BrowserState | null>;
+  /**
+   * Get browser state for a thread (implements abstract method from base class).
+   * Sync version that uses existing manager lookup without creating sessions.
+   */
+  protected getBrowserStateForThread(threadId?: string): BrowserState | null;
+  /**
+   * Get browser state from a specific Stagehand instance.
+   */
+  private getBrowserStateFromStagehand;
+  /**
+   * Get all open tabs with their URLs and titles.
+   */
+  getTabState(threadId?: string): Promise<BrowserTabState[]>;
+  /**
+   * Get the active tab index.
+   */
+  getActiveTabIndex(threadId?: string): Promise<number>;
+  startScreencast(options?: ScreencastOptions): Promise<ScreencastStream>;
+  /**
+   * Set up listeners to detect tab changes and reconnect the screencast.
+   * Uses CDP Target events since Stagehand doesn't expose page lifecycle events.
+   */
+  private setupTabChangeDetection;
+  injectMouseEvent(event: MouseEventParams, threadId?: string): Promise<void>;
+  injectKeyboardEvent(event: KeyboardEventParams, threadId?: string): Promise<void>;
 }
-
+//#endregion
+//#region src/utils.d.ts
 /**
  * Extract the Chrome process PID from a Stagehand instance.
  *
@@ -592,17 +577,13 @@ declare class StagehandBrowser extends MastraBrowser {
  * Returns undefined if the PID can't be found (e.g. BROWSERBASE env, not yet init'd).
  */
 declare function getStagehandChromePid(stagehand: Stagehand): number | undefined;
-
-/**
- * Stagehand Tools
- *
- * Creates AI-powered browser tools bound to a StagehandBrowser instance.
- */
-
+//#endregion
+//#region src/tools/index.d.ts
 /**
  * Creates all Stagehand tools bound to a StagehandBrowser instance.
  * The browser is lazily initialized on first tool use.
  */
 declare function createStagehandTools(browser: StagehandBrowser): Record<string, Tool<any, any>>;
-
-export { type ActInput, type ActResult, type CloseInput, type ExtractInput, type ExtractResult, type ModelConfiguration, type NavigateInput, type ObserveInput, type ObserveResult, STAGEHAND_TOOLS, type StagehandAction, StagehandBrowser, type StagehandBrowserConfig, type StagehandToolName, type TabsInput, actInputSchema, closeInputSchema, createStagehandTools, extractInputSchema, getStagehandChromePid, navigateInputSchema, observeInputSchema, stagehandSchemas, tabsInputSchema };
+//#endregion
+export { type ActInput, type ActResult, type CloseInput, type ExtractInput, type ExtractResult, type ModelConfiguration, type NavigateInput, type ObserveInput, type ObserveResult, STAGEHAND_MODEL_PROVIDERS, STAGEHAND_TOOLS, type StagehandAction, StagehandBrowser, type StagehandBrowserConfig, type StagehandToolName, type TabsInput, actInputSchema, closeInputSchema, createStagehandTools, extractInputSchema, getStagehandChromePid, navigateInputSchema, observeInputSchema, stagehandSchemas, tabsInputSchema };
+//# sourceMappingURL=index.d.cts.map