@mastra/agent-browser 0.0.0 → 0.1.0

package/dist/index.js

@@ -5,12 +5,9 @@ import { z } from 'zod';
 
 // src/agent-browser.ts
 var AgentBrowserThreadManager = class extends ThreadManager {
-  sharedManager = null;
   browserConfig;
   resolveCdpUrl;
   onBrowserCreated;
-  /** Map of thread ID to dedicated browser manager (for 'thread' scope) */
-  threadBrowsers = /* @__PURE__ */ new Map();
   constructor(config) {
     super(config);
     this.browserConfig = config.browserConfig;
@@ -18,25 +15,11 @@ var AgentBrowserThreadManager = class extends ThreadManager {
     this.onBrowserCreated = config.onBrowserCreated;
   }
   /**
-   * Set the shared browser manager (called after browser launch).
+   * Get the page for a specific thread, creating session if needed.
    */
-  setSharedManager(manager) {
-    this.sharedManager = manager;
-  }
-  /**
-   * Clear the shared browser manager (called when browser disconnects).
-   */
-  clearSharedManager() {
-    this.sharedManager = null;
-  }
-  /**
-   * Get the shared browser manager.
-   */
-  getSharedManager() {
-    if (!this.sharedManager) {
-      throw new Error("Browser not launched");
-    }
-    return this.sharedManager;
+  async getPageForThread(threadId) {
+    const manager = await this.getManagerForThread(threadId);
+    return manager.getPage();
   }
   /**
    * Create a new session for a thread.
@@ -67,7 +50,7 @@ var AgentBrowserThreadManager = class extends ThreadManager {
         throw error;
       }
       session.manager = manager;
-      this.threadBrowsers.set(threadId, 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`);
@@ -75,7 +58,7 @@ var AgentBrowserThreadManager = class extends ThreadManager {
         }
         this.onBrowserCreated?.(manager, threadId);
       } catch (error) {
-        this.threadBrowsers.delete(threadId);
+        this.threadManagers.delete(threadId);
         session.manager = void 0;
         try {
           await manager.close();
@@ -115,13 +98,6 @@ var AgentBrowserThreadManager = class extends ThreadManager {
       this.logger?.warn?.(`Failed to restore browser state: ${error}`);
     }
   }
-  /**
-   * Switch to an existing session.
-   * For 'thread' scope, no switching needed - each thread has its own manager.
-   * For 'shared' scope, nothing to switch.
-   */
-  async switchToSession(_session) {
-  }
   /**
    * Get the browser manager for a specific session.
    */
@@ -137,61 +113,15 @@ var AgentBrowserThreadManager = class extends ThreadManager {
   async doDestroySession(session) {
     if (this.scope === "thread" && session.manager) {
       await session.manager.close();
-      this.threadBrowsers.delete(session.threadId);
     }
   }
   /**
    * Destroy all sessions (called during browser close).
+   * doDestroySession handles closing individual browser managers.
    */
   async destroyAllSessions() {
-    for (const [threadId, manager] of this.threadBrowsers) {
-      try {
-        await manager.close();
-      } catch {
-        this.logger?.debug?.(`Failed to close browser for thread: ${threadId}`);
-      }
-    }
-    this.threadBrowsers.clear();
     await super.destroyAllSessions();
   }
-  /**
-   * Check if any thread browsers are still running.
-   */
-  hasActiveThreadBrowsers() {
-    return this.threadBrowsers.size > 0;
-  }
-  /**
-   * Get the browser manager for an existing thread session without creating a new one.
-   * Returns null if no session exists for the thread.
-   */
-  getExistingManagerForThread(threadId) {
-    if (this.scope === "thread") {
-      return this.threadBrowsers.get(threadId) ?? null;
-    }
-    return this.sharedManager;
-  }
-  /**
-   * Clear all session tracking without closing browsers.
-   * Used when browsers have been externally closed and we just need to reset state.
-   */
-  clearAllSessions() {
-    this.threadBrowsers.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
-   */
-  clearSession(threadId) {
-    const session = this.sessions.get(threadId);
-    if (session?.browserState) {
-      this.savedBrowserStates.set(threadId, session.browserState);
-    }
-    this.threadBrowsers.delete(threadId);
-    this.sessions.delete(threadId);
-  }
 };
 var gotoInputSchema = z.object({
   url: z.string().describe("The URL to navigate to"),
@@ -560,30 +490,18 @@ function createAgentBrowserTools(browser) {
 }
 
 // src/agent-browser.ts
-var AgentBrowser = class _AgentBrowser extends MastraBrowser {
+var AgentBrowser = class extends MastraBrowser {
   id;
   name = "AgentBrowser";
   provider = "vercel-labs/agent-browser";
-  /** Primary browser manager (for 'none' mode, also used as fallback) */
-  browserManager = null;
   defaultTimeout = 3e4;
-  /** Active screencast streams per thread (for triggering reconnects on tab changes) */
-  activeScreencastStreams = /* @__PURE__ */ new Map();
-  /** Default key for shared scope */
-  static SHARED_STREAM_KEY = "__shared__";
   constructor(config = {}) {
     super(config);
     this.id = `agent-browser-${Date.now()}`;
     if (config.timeout) {
       this.defaultTimeout = config.timeout;
     }
-    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 AgentBrowserThreadManager({
       scope: effectiveScope,
       browserConfig: config,
@@ -600,13 +518,13 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
     });
   }
   // ---------------------------------------------------------------------------
-  // Thread Isolation (delegated to ThreadManager)
+  // 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 'browser' isolation, we need to create the thread session BEFORE
+   * 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.
    */
@@ -624,7 +542,7 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
   }
   /**
    * Get the browser manager for the current thread.
-   * Delegates to ThreadManager for isolation handling.
+   * Delegates to ThreadManager for scope handling.
    */
   async getManagerForThread(threadId) {
     const effectiveThreadId = threadId ?? this.getCurrentThread();
@@ -637,33 +555,17 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
     }
     return this.threadManager.getManagerForThread(effectiveThreadId);
   }
-  /**
-   * Get the page for a specific thread.
-   * For thread-isolated modes, ensures we're on the correct context/page.
-   */
-  async getPageForThread(threadId) {
-    const manager = await this.getManagerForThread(threadId);
-    return manager.getPage();
-  }
-  /**
-   * Close a specific thread's browser session.
-   * Delegates to ThreadManager and notifies registered callbacks.
-   */
-  async closeThreadSession(threadId) {
-    await this.threadManager.destroySession(threadId);
-    this.notifyBrowserClosed(threadId);
-  }
   // ---------------------------------------------------------------------------
   // Lifecycle
   // ---------------------------------------------------------------------------
   async doLaunch() {
     const scope = this.threadManager.getScope();
     if (scope === "thread") {
-      this.browserManager = new BrowserManager();
-      this.threadManager.setSharedManager(this.browserManager);
+      this.sharedManager = new BrowserManager();
+      this.threadManager.setSharedManager(this.sharedManager);
       return;
     }
-    this.browserManager = new BrowserManager();
+    this.sharedManager = new BrowserManager();
     const localConfig = this.config;
     const launchOptions = {
       headless: localConfig.headless ?? true,
@@ -672,15 +574,15 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
     if (localConfig.cdpUrl) {
       launchOptions.cdpUrl = await this.resolveCdpUrl(localConfig.cdpUrl);
     }
-    await this.browserManager.launch(launchOptions);
-    this.threadManager.setSharedManager(this.browserManager);
-    this.setupCloseListenerForNoneIsolation(this.browserManager);
+    await this.sharedManager.launch(launchOptions);
+    this.threadManager.setSharedManager(this.sharedManager);
+    this.setupCloseListenerForSharedScope(this.sharedManager);
   }
   /**
-   * Set up close event listeners for 'none' isolation shared browser.
+   * Set up close event listeners for 'shared' scope browser.
    * This handles the case where the shared browser is closed externally.
    */
-  setupCloseListenerForNoneIsolation(manager) {
+  setupCloseListenerForSharedScope(manager) {
     try {
       let disconnectHandled = false;
       const handleDisconnect = () => {
@@ -708,10 +610,10 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
     await this.threadManager.destroyAllSessions();
     this.setCurrentThread(void 0);
     const scope = this.threadManager.getScope();
-    if (scope === "shared" && this.browserManager) {
-      await this.browserManager.close();
+    if (scope === "shared" && this.sharedManager) {
+      await this.sharedManager.close();
     }
-    this.browserManager = null;
+    this.sharedManager = null;
   }
   /**
    * Check if the browser is still alive by verifying the page is connected.
@@ -720,13 +622,13 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
   async checkBrowserAlive() {
     const scope = this.threadManager.getScope();
     if (scope === "thread") {
-      return this.threadManager.hasActiveThreadBrowsers();
+      return this.threadManager.hasActiveThreadManagers();
     }
-    if (!this.browserManager) {
+    if (!this.sharedManager) {
       return false;
     }
     try {
-      const page = this.browserManager.getPage();
+      const page = this.sharedManager.getPage();
       const url = page.url();
       if (url && url !== "about:blank") {
         const state = await this.getBrowserState();
@@ -765,28 +667,21 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
   async getPage(explicitThreadId) {
     const scope = this.getScope();
     const threadId = explicitThreadId ?? this.getCurrentThread();
-    if (scope === "thread" || scope !== "shared" && threadId !== DEFAULT_THREAD_ID) {
-      return this.getPageForThread(threadId);
+    if (scope === "thread") {
+      return this.threadManager.getPageForThread(threadId);
     }
-    if (!this.browserManager) throw new Error("Browser not launched");
-    return this.browserManager.getPage();
+    if (!this.sharedManager) throw new Error("Browser not launched");
+    return this.sharedManager.getPage();
   }
   /**
-   * Handle browser disconnection by clearing internal state.
-   * For 'thread' scope, only notifies the specific thread's callbacks.
-   * For 'shared' scope, notifies all callbacks.
+   * Get the active page for a thread (implements abstract method from base class).
+   * Returns null if no page is available, unlike getPage which throws.
    */
-  handleBrowserDisconnected() {
-    const scope = this.threadManager.getScope();
-    const threadId = this.getCurrentThread();
-    if (scope === "thread" && threadId !== DEFAULT_THREAD_ID) {
-      this.threadManager.clearSession(threadId);
-      this.logger.debug?.(`Cleared browser session for thread: ${threadId}`);
-      this.notifyBrowserClosed(threadId);
-    } else {
-      this.browserManager = null;
-      this.threadManager.clearSharedManager();
-      super.handleBrowserDisconnected();
+  async getActivePage(threadId) {
+    try {
+      return await this.getPage(threadId);
+    } catch {
+      return null;
     }
   }
   /**
@@ -817,15 +712,6 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
     } 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 browser session for thread: ${threadId}`);
-    this.notifyBrowserClosed(threadId);
-  }
   /**
    * Create an error response from an exception.
    * Extends base class to add agent-browser specific error handling.
@@ -949,6 +835,16 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
       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);
+  }
   /**
    * Get browser state from a specific manager instance.
    */
@@ -988,29 +884,6 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
       return 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() ?? DEFAULT_THREAD_ID;
-      const scope = this.threadManager.getScope();
-      let manager = null;
-      if (scope === "thread") {
-        manager = this.threadManager.getExistingManagerForThread(effectiveThreadId);
-      } else {
-        manager = this.browserManager;
-      }
-      if (manager) {
-        const state = this.getBrowserStateForManager(manager);
-        if (state) {
-          this.threadManager.updateBrowserState(effectiveThreadId, state);
-        }
-      }
-    } catch {
-    }
-  }
   // ---------------------------------------------------------------------------
   // 1. browser_goto - Navigate to URL
   // ---------------------------------------------------------------------------
@@ -1433,10 +1306,10 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
             );
           }
           await browser.switchTo(input.index);
-          await this.reconnectScreencast("tab switch");
+          await this.reconnectScreencastForThread(threadId, "tab switch");
           const page = browser.getPage();
           const pageUrl = page.url();
-          const streamKey = this.getStreamKey(this.getCurrentThread());
+          const streamKey = this.getStreamKey(threadId);
           const stream = this.activeScreencastStreams.get(streamKey);
           if (pageUrl && stream?.isActive()) {
             stream.emitUrl(pageUrl);
@@ -1459,7 +1332,7 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
             );
           }
           await browser.closeTab(input.index);
-          await this.reconnectScreencast("tab close");
+          await this.reconnectScreencastForThread(threadId, "tab close");
           this.updateSessionBrowserState(threadId);
           const tabsList = await browser.listTabs?.() ?? [];
           return {
@@ -1555,47 +1428,15 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
   // ---------------------------------------------------------------------------
   // Screencast (for Studio live view)
   // ---------------------------------------------------------------------------
-  /**
-   * Get the stream key for a thread (or shared key for shared scope).
-   */
-  getStreamKey(threadId) {
-    return threadId || _AgentBrowser.SHARED_STREAM_KEY;
-  }
-  /**
-   * Trigger a screencast reconnect after tab changes.
-   * Called internally when tabs are switched or closed.
-   */
-  async reconnectScreencast(_reason) {
-    const threadId = this.getCurrentThread();
-    const streamKey = this.getStreamKey(threadId);
-    const stream = this.activeScreencastStreams.get(streamKey);
-    if (stream?.isActive()) {
-      await new Promise((resolve) => setTimeout(resolve, 150));
-      if (stream?.isActive()) {
-        try {
-          await stream.reconnect();
-          const manager = this.threadManager.getExistingManagerForThread(threadId) ?? this.browserManager;
-          const activePage = manager?.getPage();
-          if (activePage) {
-            const url = activePage.url();
-            if (url) {
-              stream.emitUrl(url);
-            }
-          }
-        } catch (err) {
-          console.error("[AgentBrowser] Failed to reconnect screencast:", err);
-        }
-      }
-    }
-  }
   async startScreencast(_options) {
-    const threadId = _options?.threadId;
+    const requestedThreadId = _options?.threadId;
+    const effectiveThreadId = this.getScope() === "thread" ? requestedThreadId ?? this.getCurrentThread() ?? DEFAULT_THREAD_ID : requestedThreadId;
     let browserManager;
-    if (this.getScope() === "thread" && threadId) {
-      browserManager = await this.getManagerForThread(threadId);
+    if (this.getScope() === "thread") {
+      browserManager = await this.getManagerForThread(effectiveThreadId);
     } else {
-      if (!this.browserManager) throw new Error("Browser not launched");
-      browserManager = this.browserManager;
+      if (!this.sharedManager) throw new Error("Browser not launched");
+      browserManager = this.sharedManager;
     }
     const provider = {
       getCdpSession: async () => {
@@ -1609,7 +1450,7 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
       isBrowserRunning: () => browserManager.isLaunched()
     };
     const stream = new ScreencastStreamImpl(provider, _options);
-    const streamKey = this.getStreamKey(threadId);
+    const streamKey = this.getStreamKey(effectiveThreadId);
     this.activeScreencastStreams.set(streamKey, stream);
     const context = browserManager.getContext();
     if (context) {
@@ -1628,7 +1469,7 @@ var AgentBrowser = class _AgentBrowser extends MastraBrowser {
         const onFrameNavigated = (frame) => {
           if (!frame.parentFrame()) {
             stream.emitUrl(frame.url());
-            this.updateSessionBrowserState(threadId);
+            this.updateSessionBrowserState(effectiveThreadId);
           }
         };
         page.on("framenavigated", onFrameNavigated);