@mastra/core 1.22.0-alpha.2 → 1.22.0

package/dist/browser/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var chunkVDXTOWVO_cjs = require('../chunk-VDXTOWVO.cjs');
 var chunkDKK77FIJ_cjs = require('../chunk-DKK77FIJ.cjs');
 var chunkHBO2PK7W_cjs = require('../chunk-HBO2PK7W.cjs');
 var events = require('events');
@@ -16,6 +17,68 @@ function createError(code, message, hint) {
   };
 }
 
+// src/browser/processor.ts
+var BrowserContextProcessor = class {
+  id = "browser-context";
+  processInput(args) {
+    const ctx = args.requestContext?.get("browser");
+    if (!ctx) return args.messageList;
+    const lines = [`You have access to a browser (${ctx.provider}).`];
+    if (ctx.headless === false) {
+      lines.push("The browser is running in visible mode (not headless).");
+    }
+    if (ctx.sessionId) {
+      lines.push(`Session ID: ${ctx.sessionId}`);
+    }
+    const systemMessages = [...args.systemMessages, { role: "system", content: lines.join(" ") }];
+    return { messages: args.messages, systemMessages };
+  }
+  processInputStep(args) {
+    if (args.stepNumber !== 0) return;
+    const ctx = args.requestContext?.get("browser");
+    if (!ctx) return;
+    const parts = [];
+    if (ctx.currentUrl) {
+      parts.push(`Current URL: ${ctx.currentUrl}`);
+    }
+    if (ctx.pageTitle) {
+      parts.push(`Page title: ${ctx.pageTitle}`);
+    }
+    if (ctx.isRunning === false) {
+      parts.push("Browser is not currently running.");
+    }
+    if (parts.length === 0) return;
+    const reminder = `<system-reminder>${parts.join(" | ")}</system-reminder>
+
+`;
+    const messages = [...args.messages];
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      if (msg.role === "user") {
+        const content = msg.content;
+        const existingParts = content.parts ?? [];
+        const firstTextIdx = existingParts.findIndex((p) => p.type === "text");
+        if (firstTextIdx >= 0) {
+          const textPart = existingParts[firstTextIdx];
+          const newParts = [...existingParts];
+          newParts[firstTextIdx] = { ...textPart, text: reminder + textPart.text };
+          messages[i] = { ...msg, content: { ...content, parts: newParts } };
+        } else {
+          messages[i] = {
+            ...msg,
+            content: {
+              ...content,
+              parts: [{ type: "text", text: reminder }, ...existingParts]
+            }
+          };
+        }
+        break;
+      }
+    }
+    return { messages };
+  }
+};
+
 // src/browser/thread-manager.ts
 var DEFAULT_THREAD_ID = "__default__";
 var ThreadManager = class {
@@ -25,6 +88,10 @@ var ThreadManager = class {
   activeThreadId = DEFAULT_THREAD_ID;
   /** Preserved browser state that survives session clears (for browser restore) */
   savedBrowserStates = /* @__PURE__ */ new Map();
+  /** Shared manager instance (used for 'shared' scope) */
+  sharedManager = null;
+  /** Map of thread ID to dedicated manager instance (for 'thread' scope) */
+  threadManagers = /* @__PURE__ */ new Map();
   onSessionCreated;
   onSessionDestroyed;
   constructor(config) {
@@ -45,6 +112,49 @@ var ThreadManager = class {
   getActiveThreadId() {
     return this.activeThreadId;
   }
+  /**
+   * Set the shared manager instance (called after browser launch).
+   */
+  setSharedManager(manager) {
+    this.sharedManager = manager;
+  }
+  /**
+   * Clear the shared manager instance (called when browser disconnects).
+   */
+  clearSharedManager() {
+    this.sharedManager = null;
+  }
+  /**
+   * Get the manager for an existing thread session without creating a new one.
+   *
+   * For 'thread' scope: Returns the thread-specific manager, or null if no session exists.
+   * For 'shared' scope: Returns the shared manager (all threads use the same instance).
+   *
+   * @param threadId - Thread identifier (defaults to DEFAULT_THREAD_ID)
+   * @returns The manager for the thread, or null if not found (thread scope only)
+   */
+  getExistingManagerForThread(threadId) {
+    const effectiveThreadId = threadId ?? DEFAULT_THREAD_ID;
+    if (this.scope === "thread") {
+      return this.threadManagers.get(effectiveThreadId) ?? null;
+    }
+    return this.sharedManager;
+  }
+  /**
+   * Check if any thread managers are still running (for 'thread' scope).
+   */
+  hasActiveThreadManagers() {
+    return this.threadManagers.size > 0;
+  }
+  /**
+   * Clear all session tracking without closing managers.
+   * Used when browsers have been externally closed and we just need to reset state.
+   */
+  clearAllSessions() {
+    this.threadManagers.clear();
+    this.sessions.clear();
+    this.activeThreadId = DEFAULT_THREAD_ID;
+  }
   /**
    * Get a session by thread ID.
    */
@@ -89,8 +199,6 @@ var ThreadManager = class {
       this.sessions.set(effectiveThreadId, session);
       this.logger?.debug?.(`Created thread session: ${effectiveThreadId}`);
       this.onSessionCreated?.(session);
-    } else if (this.activeThreadId !== effectiveThreadId) {
-      await this.switchToSession(session);
     }
     this.activeThreadId = effectiveThreadId;
     return this.getManagerForSession(session);
@@ -106,6 +214,7 @@ var ThreadManager = class {
       return;
     }
     await this.doDestroySession(session);
+    this.threadManagers.delete(threadId);
     this.sessions.delete(threadId);
     this.logger?.debug?.(`Destroyed thread session: ${threadId}`);
     this.onSessionDestroyed?.(threadId);
@@ -152,6 +261,37 @@ var ThreadManager = class {
     }
     return this.savedBrowserStates.get(threadId);
   }
+  /**
+   * 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.threadManagers.delete(threadId);
+    this.sessions.delete(threadId);
+    if (this.activeThreadId === threadId) {
+      this.activeThreadId = DEFAULT_THREAD_ID;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Abstract methods to be implemented by subclasses
+  // ---------------------------------------------------------------------------
+  /**
+   * Get the shared browser manager (used for 'shared' scope and default thread).
+   * @throws Error if shared manager is not initialized
+   */
+  getSharedManager() {
+    if (!this.sharedManager) {
+      throw new Error("Browser not launched");
+    }
+    return this.sharedManager;
+  }
 };
 
 // src/browser/browser.ts
@@ -172,6 +312,12 @@ var MastraBrowser = class _MastraBrowser extends chunkDKK77FIJ_cjs.MastraBase {
   }
   /** Last known browser state before browser was closed (for restore on relaunch) */
   lastBrowserState;
+  /**
+   * Shared manager instance for 'shared' scope mode.
+   * Type varies by provider (e.g., BrowserManager for agent-browser, Stagehand for stagehand).
+   * Providers should cast this to their specific type when accessing.
+   */
+  sharedManager = null;
   /** Configuration */
   config;
   /**
@@ -185,6 +331,69 @@ var MastraBrowser = class _MastraBrowser extends chunkDKK77FIJ_cjs.MastraBase {
    */
   currentThreadId = DEFAULT_THREAD_ID;
   // ---------------------------------------------------------------------------
+  // Screencast State
+  // ---------------------------------------------------------------------------
+  /** Default key for shared scope screencast streams */
+  static SHARED_STREAM_KEY = "__shared__";
+  /** Active screencast streams per thread (for triggering reconnects on tab changes) */
+  activeScreencastStreams = /* @__PURE__ */ new Map();
+  /**
+   * Get the stream key for a thread (or shared key for shared scope).
+   * @param threadId - Optional thread ID
+   * @returns The stream key to use for the screencast streams map
+   */
+  getStreamKey(threadId) {
+    return threadId || _MastraBrowser.SHARED_STREAM_KEY;
+  }
+  /**
+   * Reconnect the active screencast for a specific thread.
+   * Called internally when tabs are switched or closed.
+   */
+  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?.getExistingManagerForThread(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 activePage = await this.getActivePage(threadId);
+      if (activePage) {
+        const url = activePage.url();
+        if (url) {
+          stream.emitUrl(url);
+        }
+      }
+    } catch (error) {
+      this.logger.debug?.("Screencast reconnect failed", error);
+    }
+  }
+  /**
+   * 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 state = this.getBrowserStateForThread(effectiveThreadId);
+      if (state) {
+        this.threadManager?.updateBrowserState(effectiveThreadId, state);
+      }
+    } catch {
+    }
+  }
+  // ---------------------------------------------------------------------------
   // Lifecycle Promise Tracking (prevents race conditions)
   // ---------------------------------------------------------------------------
   _launchPromise;
@@ -195,6 +404,19 @@ var MastraBrowser = class _MastraBrowser extends chunkDKK77FIJ_cjs.MastraBase {
   constructor(config = {}) {
     super({ name: "MastraBrowser", component: chunkHBO2PK7W_cjs.RegisteredLogger.BROWSER });
     this.config = config;
+    const scope = config.scope;
+    if (config.cdpUrl && scope === "thread") {
+      throw new Error(
+        `Invalid browser configuration: "cdpUrl" and "scope: 'thread'" cannot be used together.
+
+\u2022 cdpUrl connects to a single existing browser instance (all threads share it)
+\u2022 scope: "thread" requires spawning separate browser instances per thread
+
+To fix this, either:
+1. Remove cdpUrl to let the provider spawn separate browser instances (supports thread isolation)
+2. Use scope: "shared" when connecting via cdpUrl (all threads share one browser)`
+      );
+    }
   }
   /**
    * Launch the browser.
@@ -403,13 +625,25 @@ var MastraBrowser = class _MastraBrowser extends chunkDKK77FIJ_cjs.MastraBase {
   /**
    * Handle browser disconnection by updating status and notifying listeners.
    * Called when browser is detected as externally closed.
-   * Subclasses should call this and also clear their internal instance references.
+   *
+   * For 'thread' scope: clears only the specific thread's session (other threads unaffected)
+   * For 'shared' scope: clears the shared manager and updates global status
    */
   handleBrowserDisconnected() {
-    if (this.status !== "closed") {
-      this.status = "closed";
-      this.logger.debug?.("Browser was externally closed, status set to closed");
-      this.notifyBrowserClosed();
+    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.sharedManager = null;
+      this.threadManager?.clearSharedManager();
+      if (this.status !== "closed") {
+        this.status = "closed";
+        this.logger.debug?.("Browser was externally closed, status set to closed");
+        this.notifyBrowserClosed();
+      }
     }
   }
   /**
@@ -700,6 +934,37 @@ var MastraBrowser = class _MastraBrowser extends chunkDKK77FIJ_cjs.MastraBase {
     }
     return this.threadManager.hasSession(threadId);
   }
+  /**
+   * Close a specific thread's browser session.
+   * Delegates to ThreadManager and notifies registered callbacks.
+   *
+   * For 'thread' scope, this closes only that thread's browser instance.
+   * For 'shared' scope, this is a no-op (use close() to close the shared browser).
+   *
+   * @param threadId - The thread ID whose session should be closed
+   */
+  async closeThreadSession(threadId) {
+    if (!this.threadManager) {
+      return;
+    }
+    await this.threadManager.destroySession(threadId);
+    this.notifyBrowserClosed(threadId);
+  }
+  /**
+   * Handle browser disconnection for a specific thread.
+   * Called when a thread's browser is closed externally (e.g., user closes browser window).
+   * Clears the thread session and notifies registered callbacks.
+   *
+   * @param threadId - The thread ID whose session was disconnected
+   */
+  handleThreadBrowserDisconnected(threadId) {
+    if (!this.threadManager) {
+      return;
+    }
+    this.threadManager.clearSession(threadId);
+    this.logger.debug?.(`Cleared browser session for thread: ${threadId}`);
+    this.notifyBrowserClosed(threadId);
+  }
   /**
    * Get a session identifier for a specific thread.
    * In thread scope, returns a composite ID (browser:threadId).
@@ -757,6 +1022,26 @@ var MastraBrowser = class _MastraBrowser extends chunkDKK77FIJ_cjs.MastraBase {
   async injectKeyboardEvent(_event, _threadId) {
     throw new Error("Keyboard event injection not supported by this provider");
   }
+  // ---------------------------------------------------------------------------
+  // Input Processors
+  // ---------------------------------------------------------------------------
+  /**
+   * Returns browser input processors (e.g., BrowserContextProcessor for context injection).
+   * Skips if the user already added a processor with the same id.
+   *
+   * This method is similar to AgentChannels.getInputProcessors() and allows
+   * browser implementations to provide their own processors.
+   *
+   * @param configuredProcessors - Processors already configured by the user (for deduplication)
+   * @returns Array of input processors for this browser instance
+   */
+  getInputProcessors(configuredProcessors = []) {
+    const hasProcessor = configuredProcessors.some(
+      (p) => !chunkVDXTOWVO_cjs.isProcessorWorkflow(p) && "id" in p && p.id === "browser-context"
+    );
+    if (hasProcessor) return [];
+    return [new BrowserContextProcessor()];
+  }
 };
 
 // src/browser/screencast/types.ts
@@ -929,68 +1214,6 @@ var ScreencastStream = class extends events.EventEmitter {
   }
 };
 
-// src/browser/processor.ts
-var BrowserContextProcessor = class {
-  id = "browser-context";
-  processInput(args) {
-    const ctx = args.requestContext?.get("browser");
-    if (!ctx) return args.messageList;
-    const lines = [`You have access to a browser (${ctx.provider}).`];
-    if (ctx.headless === false) {
-      lines.push("The browser is running in visible mode (not headless).");
-    }
-    if (ctx.sessionId) {
-      lines.push(`Session ID: ${ctx.sessionId}`);
-    }
-    const systemMessages = [...args.systemMessages, { role: "system", content: lines.join(" ") }];
-    return { messages: args.messages, systemMessages };
-  }
-  processInputStep(args) {
-    if (args.stepNumber !== 0) return;
-    const ctx = args.requestContext?.get("browser");
-    if (!ctx) return;
-    const parts = [];
-    if (ctx.currentUrl) {
-      parts.push(`Current URL: ${ctx.currentUrl}`);
-    }
-    if (ctx.pageTitle) {
-      parts.push(`Page title: ${ctx.pageTitle}`);
-    }
-    if (ctx.isRunning === false) {
-      parts.push("Browser is not currently running.");
-    }
-    if (parts.length === 0) return;
-    const reminder = `<system-reminder>${parts.join(" | ")}</system-reminder>
-
-`;
-    const messages = [...args.messages];
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const msg = messages[i];
-      if (msg.role === "user") {
-        const content = msg.content;
-        const existingParts = content.parts ?? [];
-        const firstTextIdx = existingParts.findIndex((p) => p.type === "text");
-        if (firstTextIdx >= 0) {
-          const textPart = existingParts[firstTextIdx];
-          const newParts = [...existingParts];
-          newParts[firstTextIdx] = { ...textPart, text: reminder + textPart.text };
-          messages[i] = { ...msg, content: { ...content, parts: newParts } };
-        } else {
-          messages[i] = {
-            ...msg,
-            content: {
-              ...content,
-              parts: [{ type: "text", text: reminder }, ...existingParts]
-            }
-          };
-        }
-        break;
-      }
-    }
-    return { messages };
-  }
-};
-
 exports.BrowserContextProcessor = BrowserContextProcessor;
 exports.DEFAULT_THREAD_ID = DEFAULT_THREAD_ID;
 exports.MastraBrowser = MastraBrowser;