@mastra/stagehand 0.1.0-alpha.0 → 0.2.0-alpha.0

package/dist/index.cjs

@@ -1,77 +1,35 @@
 'use strict';
 
+var fs = require('fs');
 var stagehand = require('@browserbasehq/stagehand');
 var browser = require('@mastra/core/browser');
 var tools = require('@mastra/core/tools');
 var zod = require('zod');
+var path = require('path');
 
 // src/stagehand-browser.ts
 var StagehandThreadManager = class extends browser.ThreadManager {
-  sharedStagehand = null;
   sessions = /* @__PURE__ */ new Map();
   createStagehand;
   onBrowserCreated;
-  /** Map of thread ID to dedicated Stagehand instance (for 'thread' mode) */
-  threadStagehands = /* @__PURE__ */ new Map();
   constructor(config) {
     super(config);
     this.createStagehand = config.createStagehand;
     this.onBrowserCreated = config.onBrowserCreated;
   }
-  /**
-   * Set the shared Stagehand instance (called after browser launch).
-   */
-  setStagehand(instance) {
-    this.sharedStagehand = instance;
-  }
-  /**
-   * Clear the shared Stagehand instance (called when browser disconnects).
-   */
-  clearStagehand() {
-    this.sharedStagehand = null;
-  }
   /**
    * Set the factory function for creating new Stagehand instances.
-   * Required for 'browser' scope mode.
+   * Required for 'thread' scope mode.
    */
   setCreateStagehand(factory) {
     this.createStagehand = factory;
   }
   /**
-   * Get the shared Stagehand instance.
-   */
-  getSharedStagehand() {
-    if (!this.sharedStagehand) {
-      throw new Error("Stagehand not initialized");
-    }
-    return this.sharedStagehand;
-  }
-  /**
-   * Get the Stagehand instance for a specific thread.
-   * In 'shared' mode, returns the shared instance.
-   * In 'thread' mode, returns the thread's dedicated instance.
-   */
-  getStagehandForThread(threadId) {
-    if (this.scope === "thread") {
-      const session = this.sessions.get(threadId);
-      return session?.stagehand;
-    }
-    return this.sharedStagehand ?? void 0;
-  }
-  /**
-   * Get the Stagehand page for a thread.
-   * Returns the active page from the thread's Stagehand instance.
-   */
-  getPageForThread(threadId) {
-    const stagehand = this.getStagehandForThread(threadId);
-    return stagehand?.context?.activePage();
-  }
-  /**
-   * Get the shared manager - returns the active page or the Stagehand instance.
+   * Get the page for a specific thread, creating session if needed.
    */
-  getSharedManager() {
-    const stagehand = this.getSharedStagehand();
-    return stagehand.context.activePage() ?? stagehand;
+  async getPageForThread(threadId) {
+    const stagehand = await this.getManagerForThread(threadId);
+    return stagehand?.context?.activePage() ?? null;
   }
   /**
    * Create a new session for a thread.
@@ -90,7 +48,7 @@ var StagehandThreadManager = class extends browser.ThreadManager {
       this.logger?.debug?.(`Creating dedicated Stagehand instance for thread ${threadId}`);
       const stagehand = await this.createStagehand();
       session.stagehand = stagehand;
-      this.threadStagehands.set(threadId, stagehand);
+      this.threadManagers.set(threadId, stagehand);
       if (savedState && savedState.tabs.length > 0) {
         this.logger?.debug?.(`Restoring browser state for thread ${threadId}: ${savedState.tabs.length} tabs`);
         await this.restoreBrowserState(stagehand, savedState);
@@ -129,18 +87,11 @@ var StagehandThreadManager = class extends browser.ThreadManager {
     }
   }
   /**
-   * Switch to an existing session.
-   * For 'thread' mode, no switching needed - each thread has its own instance.
-   * For 'shared' mode, nothing to switch.
-   */
-  async switchToSession(_session) {
-  }
-  /**
-   * Get the manager for a specific session.
+   * Get the manager (Stagehand instance) for a specific session.
    */
   getManagerForSession(session) {
     if (this.scope === "thread" && session.stagehand) {
-      return session.stagehand.context.activePage() ?? session.stagehand;
+      return session.stagehand;
     }
     return this.getSharedManager();
   }
@@ -155,50 +106,14 @@ var StagehandThreadManager = class extends browser.ThreadManager {
       } catch (error) {
         this.logger?.warn?.(`Failed to close Stagehand for thread ${session.threadId}: ${error}`);
       }
-      this.threadStagehands.delete(session.threadId);
     }
   }
   /**
-   * Clean up all thread sessions.
-   */
-  async destroyAll() {
-    for (const [threadId, stagehand] of this.threadStagehands) {
-      try {
-        await stagehand.close();
-      } catch {
-        this.logger?.debug?.(`Failed to close Stagehand for thread: ${threadId}`);
-      }
-    }
-    this.threadStagehands.clear();
-    this.sessions.clear();
-  }
-  /**
-   * Check if any thread Stagehands are still running.
-   */
-  hasActiveThreadStagehands() {
-    return this.threadStagehands.size > 0;
-  }
-  /**
-   * Clear all session tracking without closing browsers.
-   * Used when browsers have been externally closed and we just need to reset state.
-   */
-  clearAllSessions() {
-    this.threadStagehands.clear();
-    this.sessions.clear();
-  }
-  /**
-   * Clear a specific thread's session without closing the browser.
-   * Used when a thread's browser has been externally closed.
-   * Preserves the browser state for potential restoration.
-   * @param threadId - The thread ID to clear
+   * Destroy all sessions (called during browser close).
+   * doDestroySession handles closing individual Stagehand instances.
    */
-  clearSession(threadId) {
-    const session = this.sessions.get(threadId);
-    if (session?.browserState) {
-      this.savedBrowserStates.set(threadId, session.browserState);
-    }
-    this.threadStagehands.delete(threadId);
-    this.sessions.delete(threadId);
+  async destroyAllSessions() {
+    await super.destroyAllSessions();
   }
 };
 var actInputSchema = zod.z.object({
@@ -367,31 +282,44 @@ function createStagehandTools(browser) {
     [STAGEHAND_TOOLS.CLOSE]: createCloseTool(browser)
   };
 }
+function patchProfileExitType(profilePath, logger) {
+  if (!profilePath) return;
+  const prefsPath = path.join(profilePath, "Default", "Preferences");
+  try {
+    if (!fs.existsSync(prefsPath)) return;
+    const prefs = JSON.parse(fs.readFileSync(prefsPath, "utf-8"));
+    if (prefs?.profile?.exit_type === "Normal") return;
+    prefs.profile = prefs.profile || {};
+    prefs.profile.exit_type = "Normal";
+    fs.writeFileSync(prefsPath, JSON.stringify(prefs, null, 2), "utf-8");
+    logger?.debug?.(`Patched exit_type to Normal in ${prefsPath}`);
+  } catch {
+  }
+}
+function getStagehandChromePid(stagehand) {
+  try {
+    const state = stagehand.state;
+    if (state?.kind !== "LOCAL" || !state.chrome) return void 0;
+    const pid = state.chrome.process?.pid ?? state.chrome.pid;
+    return typeof pid === "number" && pid > 0 ? pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
 
 // src/stagehand-browser.ts
-var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
+var StagehandBrowser = class extends browser.MastraBrowser {
   id;
   name = "StagehandBrowser";
   provider = "browserbase/stagehand";
-  stagehand = null;
   stagehandConfig;
-  /** Active screencast streams per thread (for reconnection on tab changes) */
-  activeScreencastStreams = /* @__PURE__ */ new Map();
   /** Debounce timers per thread for tab change reconnection */
   tabChangeDebounceTimers = /* @__PURE__ */ new Map();
-  /** Default key for shared scope */
-  static SHARED_STREAM_KEY = "__shared__";
   constructor(config = {}) {
     super(config);
     this.id = `stagehand-${Date.now()}`;
     this.stagehandConfig = config;
-    let effectiveScope = config.scope ?? "thread";
-    if (config.cdpUrl && effectiveScope === "thread") {
-      this.logger.warn?.(
-        'Browser scope "thread" is not supported when connecting via cdpUrl. Falling back to "shared" (shared browser connection).'
-      );
-      effectiveScope = "shared";
-    }
+    const effectiveScope = config.cdpUrl ? config.scope ?? "shared" : config.scope ?? "thread";
     this.threadManager = new StagehandThreadManager({
       scope: effectiveScope,
       logger: this.logger,
@@ -401,19 +329,10 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
       },
       // When a new browser is created for a thread, set up close listener
       onBrowserCreated: (stagehand, threadId) => {
-        this.setupCloseListenerForThread(stagehand, threadId);
+        this.setupCloseListener(stagehand, () => this.handleThreadBrowserDisconnected(threadId), threadId);
       }
     });
   }
-  /**
-   * Close a specific thread's browser session.
-   * For 'thread' scope, this closes only that thread's Stagehand instance.
-   * For 'shared' scope, this is a no-op (use close() to close the shared browser).
-   */
-  async closeThreadSession(threadId) {
-    await this.threadManager.destroySession(threadId);
-    this.notifyBrowserClosed(threadId);
-  }
   /**
    * Ensure browser is ready and thread session exists.
    * For 'thread' scope, this creates a dedicated Stagehand instance for the thread.
@@ -424,7 +343,7 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
     const scope = this.getScope();
     const threadId = this.getCurrentThread();
     if (scope === "thread" && threadId && threadId !== browser.DEFAULT_THREAD_ID) {
-      await this.getStagehandForThread(threadId);
+      await this.getManagerForThread(threadId);
     }
   }
   // ---------------------------------------------------------------------------
@@ -453,25 +372,34 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
         stagehandOptions.projectId = config.projectId;
       }
     }
+    if (config.profile && !fs.existsSync(config.profile)) {
+      fs.mkdirSync(config.profile, { recursive: true });
+    }
     if (config.cdpUrl && config.env !== "BROWSERBASE") {
       const resolvedUrl = await this.resolveCdpUrl(config.cdpUrl);
       const wsUrl = await this.resolveWebSocketUrl(resolvedUrl);
       stagehandOptions.localBrowserLaunchOptions = {
         cdpUrl: wsUrl,
         headless: config.headless,
-        viewport: config.viewport
+        viewport: config.viewport,
+        userDataDir: config.profile,
+        executablePath: config.executablePath,
+        preserveUserDataDir: config.preserveUserDataDir
       };
     } else if (config.env !== "BROWSERBASE") {
       stagehandOptions.localBrowserLaunchOptions = {
         headless: config.headless,
-        viewport: config.viewport
+        viewport: config.viewport,
+        userDataDir: config.profile,
+        executablePath: config.executablePath,
+        preserveUserDataDir: config.preserveUserDataDir
       };
     }
     return stagehandOptions;
   }
   /**
    * Create a new Stagehand instance with the current config.
-   * Used by thread manager for 'browser' isolation mode.
+   * Used by thread manager for 'thread' scope.
    */
   async createStagehandInstance() {
     const stagehandOptions = await this.buildStagehandOptions();
@@ -485,104 +413,85 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
     if (scope === "thread") {
       return;
     }
-    this.stagehand = await this.createStagehandInstance();
-    this.threadManager.setStagehand(this.stagehand);
-    this.setupCloseListener(this.stagehand);
+    this.sharedManager = await this.createStagehandInstance();
+    this.threadManager.setSharedManager(this.sharedManager);
+    this.setupCloseListener(this.sharedManager, () => this.handleBrowserDisconnected());
   }
   /**
-   * Set up close event listener for a Stagehand instance.
+   * Set up close event listener for a shared Stagehand instance.
    * Listens to both context and page close events for robust detection.
    */
-  setupCloseListener(stagehand) {
-    let disconnectHandled = false;
-    const handleDisconnect = () => {
-      if (disconnectHandled) return;
-      disconnectHandled = true;
-      this.handleBrowserDisconnected();
-    };
-    try {
-      const context = stagehand.context;
-      if (!context) return;
-      const contextWithEvents = context;
-      if (contextWithEvents?.on) {
-        contextWithEvents.on("close", handleDisconnect);
-      }
-      const pages = context.pages?.() ?? [];
-      for (const page of pages) {
-        const pageWithEvents = page;
-        if (pageWithEvents?.on) {
-          pageWithEvents.on("close", () => {
-            const remainingPages = context.pages?.() ?? [];
-            if (remainingPages.length === 0) {
-              handleDisconnect();
-            }
-          });
-        }
-      }
-    } catch {
-    }
-  }
   /**
-   * Set up close event listener for a thread's Stagehand instance.
-   * Uses CDP Target.targetDestroyed events to detect when all pages are gone.
+   * 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).
    */
-  setupCloseListenerForThread(stagehand, threadId) {
+  setupCloseListener(stagehand, onDisconnect, threadId) {
+    const chromePid = getStagehandChromePid(stagehand);
+    if (chromePid != null) {
+      if (threadId) {
+        this.threadBrowserPids.set(threadId, chromePid);
+      } else {
+        this.sharedBrowserPid = chromePid;
+      }
+    }
     let disconnectHandled = false;
     const handleDisconnect = () => {
       if (disconnectHandled) return;
       disconnectHandled = true;
-      this.handleThreadBrowserDisconnected(threadId);
+      onDisconnect();
     };
     try {
       const stagehandAny = stagehand;
       const conn = stagehandAny.ctx?.conn;
-      if (!conn?.on) {
-        return;
-      }
+      if (!conn?.on) return;
       const pageTargets = /* @__PURE__ */ new Set();
       const context = stagehand.context;
       if (context) {
-        const pages = context.pages?.() ?? [];
-        for (const page of pages) {
-          const pageAny = page;
-          const targetId = pageAny._targetId ?? pageAny.targetId;
-          if (targetId) {
-            pageTargets.add(targetId);
-          }
+        for (const page of context.pages?.() ?? []) {
+          const targetId = page._targetId ?? page.targetId;
+          if (targetId) pageTargets.add(targetId);
         }
       }
       conn.on("Target.targetCreated", (params) => {
-        if (params.targetInfo.type === "page") {
-          pageTargets.add(params.targetInfo.targetId);
-        }
+        if (params.targetInfo.type === "page") pageTargets.add(params.targetInfo.targetId);
       });
       conn.on("Target.targetDestroyed", (params) => {
         if (pageTargets.has(params.targetId)) {
           pageTargets.delete(params.targetId);
-          if (pageTargets.size === 0) {
-            handleDisconnect();
-          }
+          if (pageTargets.size === 0) handleDisconnect();
         }
       });
     } catch {
     }
   }
-  /**
-   * Handle browser disconnection for a specific thread.
-   * Called when a thread's browser is closed externally.
-   */
-  handleThreadBrowserDisconnected(threadId) {
-    this.threadManager.clearSession(threadId);
-    this.logger.debug?.(`Cleared Stagehand session for thread: ${threadId}`);
-    this.notifyBrowserClosed(threadId);
-  }
   async doClose() {
-    await this.threadManager.destroyAll();
-    if (this.stagehand) {
-      await this.stagehand.close();
-      this.stagehand = null;
+    await this.threadManager.destroyAllSessions();
+    if (this.sharedManager) {
+      await this.sharedManager.close();
+      this.sharedManager = null;
     }
     this.setCurrentThread(void 0);
+    this.patchExitType();
+  }
+  handleBrowserDisconnected() {
+    super.handleBrowserDisconnected();
+    this.patchExitType();
+  }
+  handleThreadBrowserDisconnected(threadId) {
+    super.handleThreadBrowserDisconnected(threadId);
+    this.patchExitType();
+  }
+  async closeThreadSession(threadId) {
+    await super.closeThreadSession(threadId);
+    this.patchExitType();
+  }
+  patchExitType() {
+    if (!this.config.profile) return;
+    patchProfileExitType(this.config.profile, this.logger);
   }
   /**
    * Check if the browser is still alive by verifying the context and pages exist.
@@ -591,13 +500,13 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
   async checkBrowserAlive() {
     const scope = this.getScope();
     if (scope === "thread") {
-      return this.threadManager.hasActiveThreadStagehands();
+      return this.threadManager.hasActiveThreadManagers();
     }
-    if (!this.stagehand) {
+    if (!this.sharedManager) {
       return false;
     }
     try {
-      const context = this.stagehand.context;
+      const context = this.sharedManager.context;
       if (!context) {
         return false;
       }
@@ -607,7 +516,7 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
       }
       const url = pages[0]?.url();
       if (url && url !== "about:blank") {
-        const state = this.getBrowserStateFromStagehand(this.stagehand);
+        const state = this.getBrowserStateFromStagehand(this.sharedManager);
         if (state) {
           this.lastBrowserState = state;
         }
@@ -621,24 +530,6 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
       return false;
     }
   }
-  /**
-   * Handle browser disconnection by clearing internal state.
-   * For 'thread' scope, only notifies the specific thread's callbacks.
-   * For 'shared' scope, notifies all callbacks.
-   */
-  handleBrowserDisconnected() {
-    const scope = this.threadManager.getScope();
-    const threadId = this.getCurrentThread();
-    if (scope === "thread" && threadId !== browser.DEFAULT_THREAD_ID) {
-      this.threadManager.clearSession(threadId);
-      this.logger.debug?.(`Cleared Stagehand session for thread: ${threadId}`);
-      this.notifyBrowserClosed(threadId);
-    } else {
-      this.stagehand = null;
-      this.threadManager.clearStagehand();
-      super.handleBrowserDisconnected();
-    }
-  }
   /**
    * Create an error response from an exception.
    * Extends base class to add Stagehand-specific error handling.
@@ -659,21 +550,21 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
   // ---------------------------------------------------------------------------
   /**
    * Get the Stagehand instance for a thread, creating it if needed.
-   * For 'browser' isolation, this creates a dedicated Stagehand instance.
-   * For 'none' isolation, returns the shared instance.
+   * For 'thread' scope, this creates a dedicated Stagehand instance.
+   * For 'shared' scope, returns the shared instance.
    */
-  async getStagehandForThread(threadId) {
+  async getManagerForThread(threadId) {
     const scope = this.getScope();
     if (scope === "shared") {
-      return this.stagehand;
+      return this.sharedManager;
     }
     if (!threadId || threadId === browser.DEFAULT_THREAD_ID) {
-      return this.stagehand;
+      return this.sharedManager;
     }
-    let stagehand = this.threadManager.getStagehandForThread(threadId);
+    let stagehand = this.threadManager.getExistingManagerForThread(threadId);
     if (!stagehand) {
       await this.threadManager.getManagerForThread(threadId);
-      stagehand = this.threadManager.getStagehandForThread(threadId);
+      stagehand = this.threadManager.getExistingManagerForThread(threadId);
     }
     return stagehand ?? null;
   }
@@ -685,14 +576,14 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
    */
   requireStagehand(explicitThreadId) {
     const threadId = explicitThreadId ?? this.getCurrentThread();
-    const stagehand = this.threadManager.getStagehandForThread(threadId ?? "") ?? this.stagehand;
+    const stagehand = this.threadManager.getExistingManagerForThread(threadId) ?? this.sharedManager;
     if (!stagehand) {
       throw new Error("Browser not launched");
     }
     return stagehand;
   }
   /**
-   * Get the current page from Stagehand v3, respecting thread isolation.
+   * 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.
    */
@@ -700,15 +591,15 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
     const scope = this.getScope();
     const threadId = explicitThreadId ?? this.getCurrentThread();
     if (scope === "thread" && threadId && threadId !== browser.DEFAULT_THREAD_ID) {
-      const stagehand = this.threadManager.getStagehandForThread(threadId);
+      const stagehand = this.threadManager.getExistingManagerForThread(threadId);
       if (stagehand?.context) {
         return stagehand.context.activePage();
       }
       return null;
     }
-    if (!this.stagehand) return null;
+    if (!this.sharedManager) return null;
     try {
-      const context = this.stagehand.context;
+      const context = this.sharedManager.context;
       if (context) {
         const activePage = context.activePage();
         if (activePage) {
@@ -724,18 +615,10 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
     return null;
   }
   /**
-   * Get the page for a specific thread, creating session if needed.
+   * Get the active page for a thread (implements abstract method from base class).
    */
-  async getPageForThread(threadId) {
-    const scope = this.threadManager.getScope();
-    if (scope === "shared") {
-      return this.getPage();
-    }
-    const stagehand = await this.getStagehandForThread(threadId);
-    if (stagehand?.context) {
-      return stagehand.context.activePage();
-    }
-    return null;
+  async getActivePage(threadId) {
+    return this.getPage(threadId);
   }
   /**
    * Get a CDP session for a specific page.
@@ -986,7 +869,7 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
     const effectiveThreadId = threadId ?? this.getCurrentThread();
     const scope = this.threadManager.getScope();
     if (scope === "thread" && effectiveThreadId) {
-      const stagehand = this.threadManager.getStagehandForThread(effectiveThreadId);
+      const stagehand = this.threadManager.getExistingManagerForThread(effectiveThreadId);
       if (!stagehand?.context) {
         return null;
       }
@@ -1005,7 +888,7 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
     try {
       const url = page.url();
       if (url && url !== "about:blank") {
-        const state = this.getBrowserStateFromStagehand(this.stagehand);
+        const state = this.getBrowserStateFromStagehand(this.sharedManager);
         if (state) {
           this.lastBrowserState = state;
         }
@@ -1040,15 +923,24 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
       const scope = this.threadManager.getScope();
       const effectiveThreadId = threadId ?? this.getCurrentThread();
       if (scope === "thread" && effectiveThreadId) {
-        const stagehand = this.threadManager.getStagehandForThread(effectiveThreadId);
+        const stagehand = this.threadManager.getExistingManagerForThread(effectiveThreadId);
         if (!stagehand) return null;
         return this.getBrowserStateFromStagehand(stagehand);
       }
-      return this.getBrowserStateFromStagehand(this.stagehand);
+      return this.getBrowserStateFromStagehand(this.sharedManager);
     } 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() ?? browser.DEFAULT_THREAD_ID;
+    const stagehand = this.threadManager.getExistingManagerForThread(effectiveThreadId);
+    return this.getBrowserStateFromStagehand(stagehand);
+  }
   /**
    * Get browser state from a specific Stagehand instance.
    */
@@ -1086,44 +978,15 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
     const state = await this.getBrowserState(threadId);
     return state?.activeTabIndex ?? 0;
   }
-  /**
-   * Update the browser state in the thread session.
-   * Called on navigation, tab open/close to keep state fresh.
-   */
-  updateSessionBrowserState(threadId) {
-    try {
-      const effectiveThreadId = threadId ?? this.getCurrentThread() ?? browser.DEFAULT_THREAD_ID;
-      const scope = this.threadManager.getScope();
-      let stagehand = null;
-      if (scope === "thread") {
-        stagehand = this.threadManager.getStagehandForThread(effectiveThreadId);
-      } else {
-        stagehand = this.stagehand;
-      }
-      if (stagehand) {
-        const state = this.getBrowserStateFromStagehand(stagehand);
-        if (state) {
-          this.threadManager.updateBrowserState(effectiveThreadId, state);
-        }
-      }
-    } catch {
-    }
-  }
   // ---------------------------------------------------------------------------
   // Screencast (for Studio live view)
   // Uses Stagehand v3's native CDP access
   // ---------------------------------------------------------------------------
-  /**
-   * Get the stream key for a thread (or shared key for shared scope).
-   */
-  getStreamKey(threadId) {
-    return threadId || _StagehandBrowser.SHARED_STREAM_KEY;
-  }
   async startScreencast(options) {
     const threadId = options?.threadId;
     const provider = {
       getCdpSession: async () => {
-        const page = await this.getPageForThread(threadId ?? "");
+        const page = await this.threadManager.getPageForThread(threadId);
         if (!page) {
           throw new Error("No page available for screencast");
         }
@@ -1157,7 +1020,7 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
    * Uses CDP Target events since Stagehand doesn't expose page lifecycle events.
    */
   async setupTabChangeDetection(threadId, stream) {
-    const stagehand = await this.getStagehandForThread(threadId);
+    const stagehand = await this.getManagerForThread(threadId);
     if (!stagehand?.context) return;
     const connection = stagehand.context.conn;
     if (!connection) {
@@ -1219,7 +1082,7 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
               if (newPage && stagehand.context) {
                 stagehand.context.setActivePage(newPage);
               }
-              void this.reconnectScreencast("manual tab tracked");
+              void this.reconnectScreencastForThread(threadId, "manual tab tracked");
               void setupPageNavigationListener();
             } else {
               this.logger.debug?.("Stagehand did not register the page (non-injectable URL)");
@@ -1302,48 +1165,6 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
       this.logger.debug?.("Failed to set up tab change detection", error);
     }
   }
-  /**
-   * Reconnect the active screencast for a specific thread.
-   */
-  async reconnectScreencastForThread(threadId, reason) {
-    const streamKey = this.getStreamKey(threadId);
-    const stream = this.activeScreencastStreams.get(streamKey);
-    if (!stream || !stream.isActive()) {
-      return;
-    }
-    if (!this.isBrowserRunning()) {
-      this.logger.debug?.("Skipping screencast reconnect - browser not running");
-      return;
-    }
-    const scope = this.getScope();
-    if (scope === "thread" && threadId && !this.threadManager.getStagehandForThread(threadId)) {
-      this.logger.debug?.(`Skipping screencast reconnect - no session for thread ${threadId}`);
-      return;
-    }
-    this.logger.debug?.(`Reconnecting screencast: ${reason}`);
-    try {
-      await new Promise((resolve) => setTimeout(resolve, 150));
-      await stream.reconnect();
-      const stagehand = await this.getStagehandForThread(threadId);
-      const activePage = stagehand?.context?.activePage();
-      if (activePage) {
-        const url = activePage.url();
-        if (url) {
-          stream.emitUrl(url);
-        }
-      }
-    } catch (error) {
-      this.logger.debug?.("Screencast reconnect failed", error);
-    }
-  }
-  /**
-   * Reconnect the active screencast for the current thread.
-   * Wrapper for reconnectScreencastForThread using getCurrentThread().
-   */
-  async reconnectScreencast(reason) {
-    const threadId = this.getCurrentThread();
-    await this.reconnectScreencastForThread(threadId, reason);
-  }
   // NOTE: Manual tab switching in browser UI is not fully supported.
   // Stagehand v3 does not track pages opened via browser UI (only pages created through its API).
   // We've requested this feature from Browserbase - see Notion doc for details.
@@ -1352,7 +1173,7 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
   // ---------------------------------------------------------------------------
   async injectMouseEvent(event, threadId) {
     const effectiveThreadId = threadId ?? this.getCurrentThread();
-    const page = await this.getPageForThread(effectiveThreadId ?? "");
+    const page = await this.threadManager.getPageForThread(effectiveThreadId);
     const cdpSession = this.getCdpSessionForPage(page);
     if (!cdpSession) {
       throw new Error("No CDP session available");
@@ -1378,7 +1199,7 @@ var StagehandBrowser = class _StagehandBrowser extends browser.MastraBrowser {
   }
   async injectKeyboardEvent(event, threadId) {
     const effectiveThreadId = threadId ?? this.getCurrentThread();
-    const page = await this.getPageForThread(effectiveThreadId ?? "");
+    const page = await this.threadManager.getPageForThread(effectiveThreadId);
     const cdpSession = this.getCdpSessionForPage(page);
     if (!cdpSession) {
       throw new Error("No CDP session available");
@@ -1400,6 +1221,7 @@ exports.actInputSchema = actInputSchema;
 exports.closeInputSchema = closeInputSchema;
 exports.createStagehandTools = createStagehandTools;
 exports.extractInputSchema = extractInputSchema;
+exports.getStagehandChromePid = getStagehandChromePid;
 exports.navigateInputSchema = navigateInputSchema;
 exports.observeInputSchema = observeInputSchema;
 exports.stagehandSchemas = stagehandSchemas;