camel-ai 0.2.76a0__py3-none-any.whl → 0.2.76a1__py3-none-any.whl

camel/toolkits/hybrid_browser_toolkit/ts/src/config-loader.ts

@@ -73,6 +73,7 @@ export interface BrowserConfig {
   // CDP connection options
   connectOverCdp: boolean;
   cdpUrl?: string;
+  cdpKeepCurrentPage: boolean;
 }
 
 export interface WebSocketConfig {
@@ -118,7 +119,7 @@ function getDefaultBrowserConfig(): BrowserConfig {
     consoleLogLimit: 1000,
     scrollPositionScale: 0.1,
     navigationDelay: 100,
-    blankPageUrls: [],
+    blankPageUrls: ['chrome://newtab/', 'edge://newtab/', 'chrome://new-tab-page/'],
     dataUrlPrefix: 'data:',
     domContentLoadedState: 'domcontentloaded',
     networkIdleState: 'networkidle',
@@ -139,7 +140,8 @@ function getDefaultBrowserConfig(): BrowserConfig {
       height: 720
     },
     connectOverCdp: false,
-    cdpUrl: undefined
+    cdpUrl: undefined,
+    cdpKeepCurrentPage: false
   };
 }
 
@@ -218,6 +220,7 @@ export class ConfigLoader {
     // CDP connection options
     if (config.connectOverCdp !== undefined) browserConfig.connectOverCdp = config.connectOverCdp;
     if (config.cdpUrl !== undefined) browserConfig.cdpUrl = config.cdpUrl;
+    if (config.cdpKeepCurrentPage !== undefined) browserConfig.cdpKeepCurrentPage = config.cdpKeepCurrentPage;
 
     return new ConfigLoader(browserConfig, wsConfig);
   }

camel/toolkits/hybrid_browser_toolkit/ts/src/hybrid-browser-toolkit.ts

@@ -15,7 +15,7 @@ export class HybridBrowserToolkit {
   constructor(config: BrowserToolkitConfig = {}) {
     this.configLoader = ConfigLoader.fromPythonConfig(config);
     this.config = config; // Store original config for backward compatibility
-    this.session = new HybridBrowserSession(this.configLoader.getBrowserConfig()); // Pass processed config
+    this.session = new HybridBrowserSession(config); // Pass original config
     this.viewportLimit = this.configLoader.getWebSocketConfig().viewport_limit;
     this.fullVisualMode = this.configLoader.getWebSocketConfig().fullVisualMode || false;
   }
@@ -26,9 +26,54 @@ export class HybridBrowserToolkit {
     try {
       await this.session.ensureBrowser();
       
-      const url = startUrl || this.config.defaultStartUrl || 'https://google.com/';
-      const result = await this.session.visitPage(url);
+      // Check if we should skip navigation in CDP keep-current-page mode
+      const browserConfig = this.configLoader.getBrowserConfig();
+      if (browserConfig.cdpUrl && browserConfig.cdpKeepCurrentPage && !startUrl) {
+        // In CDP keep-current-page mode without explicit URL, just ensure browser and return current page
+        const snapshotStart = Date.now();
+        const snapshot = await this.getSnapshotForAction(this.viewportLimit);
+        const snapshotTime = Date.now() - snapshotStart;
+        
+        const page = await this.session.getCurrentPage();
+        const currentUrl = page ? await page.url() : 'unknown';
+        
+        const totalTime = Date.now() - startTime;
+        
+        return {
+          success: true,
+          message: `Browser opened in CDP keep-current-page mode (current page: ${currentUrl})`,
+          snapshot,
+          timing: {
+            total_time_ms: totalTime,
+            snapshot_time_ms: snapshotTime,
+          },
+        };
+      }
       
+      // For normal mode or CDP with cdpKeepCurrentPage=false: navigate to URL
+      if (!browserConfig.cdpUrl || !browserConfig.cdpKeepCurrentPage) {
+        const url = startUrl || this.config.defaultStartUrl || 'https://google.com/';
+        const result = await this.session.visitPage(url);
+        
+        const snapshotStart = Date.now();
+        const snapshot = await this.getSnapshotForAction(this.viewportLimit);
+        const snapshotTime = Date.now() - snapshotStart;
+        
+        const totalTime = Date.now() - startTime;
+        
+        return {
+          success: true,
+          message: result.message,
+          snapshot,
+          timing: {
+            total_time_ms: totalTime,
+            page_load_time_ms: result.timing?.page_load_time_ms || 0,
+            snapshot_time_ms: snapshotTime,
+          },
+        };
+      }
+      
+      // Fallback: Just return current page snapshot without any navigation
       const snapshotStart = Date.now();
       const snapshot = await this.getSnapshotForAction(this.viewportLimit);
       const snapshotTime = Date.now() - snapshotStart;
@@ -37,11 +82,10 @@ export class HybridBrowserToolkit {
       
       return {
         success: true,
-        message: `Browser opened and navigated to ${url}`,
+        message: `Browser opened without navigation`,
         snapshot,
         timing: {
           total_time_ms: totalTime,
-          ...result.timing,
           snapshot_time_ms: snapshotTime,
         },
       };
@@ -216,19 +260,27 @@ export class HybridBrowserToolkit {
   private async executeActionWithSnapshot(action: BrowserAction): Promise<any> {
     const result = await this.session.executeAction(action);
     
-    // Format response for Python layer compatibility
     const response: any = {
       result: result.message,
       snapshot: '',
     };
     
     if (result.success) {
-      const snapshotStart = Date.now();
-      response.snapshot = await this.getPageSnapshot(this.viewportLimit);
-      const snapshotTime = Date.now() - snapshotStart;
-      
-      if (result.timing) {
-        result.timing.snapshot_time_ms = snapshotTime;
+      if (result.details?.diffSnapshot) {
+        response.snapshot = result.details.diffSnapshot;
+        
+        if (result.timing) {
+          result.timing.snapshot_time_ms = 0; // Diff snapshot time is included in action time
+        }
+      } else {
+        // Get full snapshot as usual
+        const snapshotStart = Date.now();
+        response.snapshot = await this.getPageSnapshot(this.viewportLimit);
+        const snapshotTime = Date.now() - snapshotStart;
+        
+        if (result.timing) {
+          result.timing.snapshot_time_ms = snapshotTime;
+        }
       }
     }
     
@@ -242,6 +294,14 @@ export class HybridBrowserToolkit {
       response.newTabId = result.newTabId;
     }
     
+    // Include details if present (excluding diffSnapshot as it's already in snapshot)
+    if (result.details) {
+      const { diffSnapshot, ...otherDetails } = result.details;
+      if (Object.keys(otherDetails).length > 0) {
+        response.details = otherDetails;
+      }
+    }
+    
     return response;
   }
 

camel/toolkits/hybrid_browser_toolkit/ts/src/snapshot-parser.ts

@@ -21,26 +21,19 @@ export function parseSnapshotHierarchy(snapshotText: string): Map<string, Snapsh
   for (const line of lines) {
     if (!line.trim()) continue;
     
-    // Calculate indentation
     const indent = line.length - line.trimStart().length;
     
-    // Extract element info using regex
-    // Support both lines with : (have children) and without : (leaf nodes)
-    // Also support quoted lines like - 'button "text" [ref=...]'
-    // Also support escaped quotes in text
-    // Also support attributes before [ref=...]
-    // Extract type and optional label (before any [..] blocks)
+    // Extract type and optional label
     const headerMatch = line.match(/^\s*(?:-\s*)?'?([a-z0-9_-]+)(?:\s+"((?:[^"\\]|\\.)*)")?/i);
     if (!headerMatch) continue;
     const [, typeRaw, label] = headerMatch;
     const type = (typeRaw || 'unknown');
 
-    // Extract mandatory ref
     const refMatch = line.match(/\[ref=([^\]]+)\]/i);
     if (!refMatch) continue;
     const ref = refMatch[1];
 
-    // Parse all bracketed attributes except the [ref=...] block
+    // Parse bracketed attributes
     const attrs: Record<string, string> = {};
     for (const block of line.matchAll(/\[([^\]]+)\]/g)) {
       const content = block[1];
@@ -53,12 +46,10 @@ export function parseSnapshotHierarchy(snapshotText: string): Map<string, Snapsh
       }
     }
     
-    // Update parent stack based on indentation
     while (parentStack.length > 0 && parentStack[parentStack.length - 1].indent >= indent) {
       parentStack.pop();
     }
     
-    // Create node
     const node: SnapshotNode = {
       ref,
       type: type.toLowerCase(),
@@ -68,15 +59,12 @@ export function parseSnapshotHierarchy(snapshotText: string): Map<string, Snapsh
       parent: parentStack.length > 0 ? parentStack[parentStack.length - 1].ref : undefined
     };
     
-    // Add to parent's children if has parent
     if (node.parent && nodes.has(node.parent)) {
       nodes.get(node.parent)!.children.push(ref);
     }
     
-    // Add to nodes map
     nodes.set(ref, node);
     
-    // Add to parent stack
     parentStack.push({ ref, indent });
   }
   

camel/toolkits/hybrid_browser_toolkit/ts/src/types.ts

@@ -72,6 +72,7 @@ export interface BrowserToolkitConfig {
   useNativePlaywrightMapping?: boolean; // New option to control mapping implementation
   connectOverCdp?: boolean; // Whether to connect to existing browser via CDP
   cdpUrl?: string; // WebSocket endpoint URL for CDP connection
+  cdpKeepCurrentPage?: boolean; // When true, CDP mode will keep the current page instead of creating new one
 }
 
 export interface ClickAction {

camel/toolkits/hybrid_browser_toolkit/ws_wrapper.py

@@ -45,23 +45,19 @@ def action_logger(func):
         action_name = func.__name__
         start_time = time.time()
 
-        # Log inputs (skip self)
         inputs = {
             "args": args,
             "kwargs": kwargs,
         }
 
         try:
-            # Execute the original function
             result = await func(self, *args, **kwargs)
             execution_time = time.time() - start_time
 
-            # Extract page load time if available
             page_load_time = None
             if isinstance(result, dict) and 'page_load_time_ms' in result:
                 page_load_time = result['page_load_time_ms'] / 1000.0
 
-            # Log success
             await self._log_action(
                 action_name=action_name,
                 inputs=inputs,
@@ -76,7 +72,6 @@ def action_logger(func):
             execution_time = time.time() - start_time
             error_msg = f"{type(e).__name__}: {e!s}"
 
-            # Log error
             await self._log_action(
                 action_name=action_name,
                 inputs=inputs,
@@ -111,14 +106,11 @@ class WebSocketBrowserWrapper:
         self.process: Optional[subprocess.Popen] = None
         self.websocket = None
         self.server_port = None
-        self._send_lock = asyncio.Lock()  # Lock for sending messages
-        self._receive_task = None  # Background task for receiving messages
-        self._pending_responses: Dict[
-            str, asyncio.Future[Dict[str, Any]]
-        ] = {}  # Message ID -> Future
-        self._server_ready_future = None  # Future to track server ready state
-
-        # Logging configuration
+        self._send_lock = asyncio.Lock()
+        self._receive_task = None
+        self._pending_responses: Dict[str, asyncio.Future[Dict[str, Any]]] = {}
+        self._server_ready_future = None
+
         self.browser_log_to_file = (config or {}).get(
             'browser_log_to_file', False
         )
@@ -127,10 +119,9 @@ class WebSocketBrowserWrapper:
         self.log_file_path: Optional[str] = None
         self.log_buffer: List[Dict[str, Any]] = []
         self.ts_log_file_path: Optional[str] = None
-        self.ts_log_file = None  # File handle for TypeScript logs
-        self._log_reader_task = None  # Task for reading and logging stdout
+        self.ts_log_file = None
+        self._log_reader_task = None
 
-        # Set up log files if needed
         if self.browser_log_to_file:
             log_dir = self.log_dir if self.log_dir else "browser_log"
             os.makedirs(log_dir, exist_ok=True)
@@ -139,7 +130,6 @@ class WebSocketBrowserWrapper:
                 log_dir,
                 f"hybrid_browser_toolkit_ws_{timestamp}_{self.session_id}.log",
             )
-            # Add TypeScript console log file
             self.ts_log_file_path = os.path.join(
                 log_dir,
                 f"typescript_console_{timestamp}_{self.session_id}.log",
@@ -154,9 +144,53 @@ class WebSocketBrowserWrapper:
         """Async context manager exit."""
         await self.stop()
 
+    async def _cleanup_existing_processes(self):
+        """Clean up any existing Node.js WebSocket server processes."""
+        import psutil
+
+        cleaned_count = 0
+        for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
+            try:
+                if (
+                    proc.info['name']
+                    and 'node' in proc.info['name'].lower()
+                    and proc.info['cmdline']
+                    and any(
+                        'websocket-server.js' in arg
+                        for arg in proc.info['cmdline']
+                    )
+                ):
+                    if any(self.ts_dir in arg for arg in proc.info['cmdline']):
+                        logger.warning(
+                            f"Found existing WebSocket server process "
+                            f"(PID: {proc.info['pid']}). "
+                            f"Terminating it to prevent conflicts."
+                        )
+                        proc.terminate()
+                        try:
+                            proc.wait(timeout=3)
+                        except psutil.TimeoutExpired:
+                            proc.kill()
+                        cleaned_count += 1
+            except (
+                psutil.NoSuchProcess,
+                psutil.AccessDenied,
+                psutil.ZombieProcess,
+            ):
+                pass
+
+        if cleaned_count > 0:
+            logger.warning(
+                f"Cleaned up {cleaned_count} existing WebSocket server "
+                f"process(es). This may have been caused by improper "
+                f"shutdown in previous sessions."
+            )
+            await asyncio.sleep(0.5)
+
     async def start(self):
         """Start the WebSocket server and connect to it."""
-        # Check if npm is installed
+        await self._cleanup_existing_processes()
+
         npm_check = subprocess.run(
             ['npm', '--version'],
             capture_output=True,
@@ -169,7 +203,6 @@ class WebSocketBrowserWrapper:
                 "to use the hybrid browser toolkit."
             )
 
-        # Check if node is installed
         node_check = subprocess.run(
             ['node', '--version'],
             capture_output=True,
@@ -182,7 +215,6 @@ class WebSocketBrowserWrapper:
                 "to use the hybrid browser toolkit."
             )
 
-        # Check if node_modules exists (dependencies installed)
         node_modules_path = os.path.join(self.ts_dir, 'node_modules')
         if not os.path.exists(node_modules_path):
             logger.warning("Node modules not found. Running npm install...")
@@ -200,7 +232,6 @@ class WebSocketBrowserWrapper:
                 )
             logger.info("npm dependencies installed successfully")
 
-        # Ensure the TypeScript code is built
         build_result = subprocess.run(
             ['npm', 'run', 'build'],
             cwd=self.ts_dir,
@@ -213,20 +244,17 @@ class WebSocketBrowserWrapper:
                 f"TypeScript build failed: {build_result.stderr}"
             )
 
-        # Start the WebSocket server
         self.process = subprocess.Popen(
             ['node', 'websocket-server.js'],
             cwd=self.ts_dir,
             stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,  # Redirect stderr to stdout
+            stderr=subprocess.STDOUT,
             text=True,
-            bufsize=1,  # Line buffered
+            bufsize=1,
         )
 
-        # Create a future to wait for server ready (before starting log reader)
         self._server_ready_future = asyncio.get_running_loop().create_future()
 
-        # Start log reader task immediately after process starts
         self._log_reader_task = asyncio.create_task(
             self._read_and_log_output()
         )
@@ -237,11 +265,9 @@ class WebSocketBrowserWrapper:
                 f"{self.ts_log_file_path}"
             )
 
-        # Wait for server to output the port
         server_ready = False
-        timeout = 10  # 10 seconds timeout
+        timeout = 10
 
-        # Wait for the server to be ready
         try:
             await asyncio.wait_for(self._server_ready_future, timeout=timeout)
             server_ready = True
@@ -252,14 +278,11 @@ class WebSocketBrowserWrapper:
             with contextlib.suppress(ProcessLookupError, Exception):
                 self.process.kill()
             with contextlib.suppress(Exception):
-                # Ensure the process fully exits
                 self.process.wait(timeout=2)
-            # Cancel and await the log reader task
             if self._log_reader_task and not self._log_reader_task.done():
                 self._log_reader_task.cancel()
                 with contextlib.suppress(asyncio.CancelledError):
                     await self._log_reader_task
-            # Close TS log file if open
             if getattr(self, 'ts_log_file', None):
                 with contextlib.suppress(Exception):
                     self.ts_log_file.close()
@@ -270,7 +293,7 @@ class WebSocketBrowserWrapper:
             import psutil
 
             mem = psutil.virtual_memory()
-            if mem.available < 1024**3:  # Less than 1GB available
+            if mem.available < 1024**3:
                 error_msg = (
                     f"WebSocket server failed to start"
                     f"(likely due to insufficient memory). "
@@ -280,16 +303,59 @@ class WebSocketBrowserWrapper:
 
             raise RuntimeError(error_msg)
 
-        # Connect to the WebSocket server
-        try:
-            self.websocket = await websockets.connect(
-                f"ws://localhost:{self.server_port}",
-                ping_interval=30,
-                ping_timeout=10,
-                max_size=50 * 1024 * 1024,  # 50MB limit to match server
-            )
-            logger.info("Connected to WebSocket server")
-        except Exception as e:
+        max_retries = 3
+        retry_delays = [1, 2, 4]
+
+        for attempt in range(max_retries):
+            try:
+                connect_timeout = 10.0 + (attempt * 5.0)
+
+                logger.info(
+                    f"Attempting to connect to WebSocket server "
+                    f"(attempt {attempt + 1}/{max_retries}, "
+                    f"timeout: {connect_timeout}s)"
+                )
+
+                self.websocket = await asyncio.wait_for(
+                    websockets.connect(
+                        f"ws://localhost:{self.server_port}",
+                        ping_interval=30,
+                        ping_timeout=10,
+                        max_size=50 * 1024 * 1024,
+                    ),
+                    timeout=connect_timeout,
+                )
+                logger.info("Connected to WebSocket server")
+                break
+
+            except asyncio.TimeoutError:
+                if attempt < max_retries - 1:
+                    delay = retry_delays[attempt]
+                    logger.warning(
+                        f"WebSocket handshake timeout "
+                        f"(attempt {attempt + 1}/{max_retries}). "
+                        f"Retrying in {delay} seconds..."
+                    )
+                    await asyncio.sleep(delay)
+                else:
+                    raise RuntimeError(
+                        f"Failed to connect to WebSocket server after "
+                        f"{max_retries} attempts: Handshake timeout"
+                    )
+
+            except Exception as e:
+                if attempt < max_retries - 1 and "timed out" in str(e).lower():
+                    delay = retry_delays[attempt]
+                    logger.warning(
+                        f"WebSocket connection failed "
+                        f"(attempt {attempt + 1}/{max_retries}): {e}. "
+                        f"Retrying in {delay} seconds..."
+                    )
+                    await asyncio.sleep(delay)
+                else:
+                    break
+
+        if not self.websocket:
             with contextlib.suppress(ProcessLookupError, Exception):
                 self.process.kill()
             with contextlib.suppress(Exception):
@@ -304,39 +370,35 @@ class WebSocketBrowserWrapper:
                 self.ts_log_file = None
             self.process = None
 
-            error_msg = f"Failed to connect to WebSocket server: {e}"
             import psutil
 
             mem = psutil.virtual_memory()
-            if mem.available < 1024**3:  # Less than 1GB available
+
+            error_msg = (
+                "Failed to connect to WebSocket server after multiple attempts"
+            )
+            if mem.available < 1024**3:
                 error_msg = (
-                    f"Failed to connect to WebSocket server"
+                    f"Failed to connect to WebSocket server "
                     f"(likely due to insufficient memory). "
-                    f"Available memory: {mem.available / 1024**3:.2f}GB"
-                    f"({mem.percent}% used). "
-                    f"Original error: {e}"
+                    f"Available memory: {mem.available / 1024**3:.2f}GB "
+                    f"({mem.percent}% used)"
                 )
 
-            raise RuntimeError(error_msg) from e
+            raise RuntimeError(error_msg)
 
-        # Start the background receiver task
         self._receive_task = asyncio.create_task(self._receive_loop())
 
-        # Initialize the browser toolkit
         await self._send_command('init', self.config)
 
     async def stop(self):
         """Stop the WebSocket connection and server."""
-        # First, send shutdown command while receive task is still running
         if self.websocket:
             with contextlib.suppress(asyncio.TimeoutError, Exception):
-                # Send shutdown command with a short timeout
                 await asyncio.wait_for(
                     self._send_command('shutdown', {}),
-                    timeout=2.0,  # 2 second timeout for shutdown
+                    timeout=2.0,
                 )
-                # Note: TimeoutError is expected as server may close
-                # before responding
 
             # Close websocket connection
             with contextlib.suppress(Exception):
@@ -381,6 +443,53 @@ class WebSocketBrowserWrapper:
         # Ensure process handle cleared
         self.process = None
 
+    async def disconnect_only(self):
+        """Disconnect WebSocket and stop server without closing the browser.
+
+        This is useful for CDP mode where the browser should remain open.
+        """
+        # Close websocket connection
+        if self.websocket:
+            with contextlib.suppress(Exception):
+                await self.websocket.close()
+            self.websocket = None
+
+        # Stop the Node process
+        if self.process:
+            try:
+                # Send SIGTERM to gracefully shutdown
+                self.process.terminate()
+                self.process.wait(timeout=3)
+            except subprocess.TimeoutExpired:
+                # Force kill if needed
+                with contextlib.suppress(ProcessLookupError, Exception):
+                    self.process.kill()
+                    self.process.wait()
+            except Exception as e:
+                logger.warning(f"Error terminating process: {e}")
+
+        # Cancel background tasks
+        tasks_to_cancel = [
+            ('_receive_task', self._receive_task),
+            ('_log_reader_task', self._log_reader_task),
+        ]
+        for _, task in tasks_to_cancel:
+            if task and not task.done():
+                task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await task
+
+        # Close TS log file if open
+        if getattr(self, 'ts_log_file', None):
+            with contextlib.suppress(Exception):
+                self.ts_log_file.close()
+            self.ts_log_file = None
+
+        # Ensure process handle cleared
+        self.process = None
+
+        logger.info("WebSocket disconnected without closing browser")
+
     async def _log_action(
         self,
         action_name: str,
@@ -454,7 +563,16 @@ class WebSocketBrowserWrapper:
                 except asyncio.CancelledError:
                     break
                 except Exception as e:
-                    logger.error(f"Error in receive loop: {e}")
+                    # Check if it's a normal WebSocket close
+                    if isinstance(e, websockets.exceptions.ConnectionClosed):
+                        if e.code == 1000:  # Normal closure
+                            logger.debug(f"WebSocket closed normally: {e}")
+                        else:
+                            logger.warning(
+                                f"WebSocket closed with code {e.code}: {e}"
+                            )
+                    else:
+                        logger.error(f"Error in receive loop: {e}")
                     # Notify all pending futures of the error
                     for future in self._pending_responses.values():
                         if not future.done():
@@ -471,7 +589,7 @@ class WebSocketBrowserWrapper:
             import psutil
 
             mem = psutil.virtual_memory()
-            if mem.available < 1024**3:  # Less than 1GB available
+            if mem.available < 1024**3:
                 error_msg = (
                     f"WebSocket not connected "
                     f"(likely due to insufficient memory). "
@@ -494,7 +612,7 @@ class WebSocketBrowserWrapper:
             import psutil
 
             mem = psutil.virtual_memory()
-            if mem.available < 1024**3:  # Less than 1GB available
+            if mem.available < 1024**3:
                 error_msg = (
                     f"WebSocket connection lost "
                     f"(likely due to insufficient memory). "
@@ -542,6 +660,16 @@ class WebSocketBrowserWrapper:
             except asyncio.TimeoutError:
                 # Remove from pending if timeout
                 self._pending_responses.pop(message_id, None)
+                # Special handling for shutdown command
+                if command == 'shutdown':
+                    logger.debug(
+                        "Shutdown command timeout is expected - "
+                        "server may have closed before responding"
+                    )
+                    # Return a success response for shutdown
+                    return {
+                        'message': 'Browser shutdown (no response received)'
+                    }
                 raise RuntimeError(
                     f"Timeout waiting for response to command: {command}"
                 )
@@ -555,6 +683,12 @@ class WebSocketBrowserWrapper:
                 "close frame" in str(e)
                 or "connection closed" in str(e).lower()
             ):
+                # Special handling for shutdown command
+                if command == 'shutdown':
+                    logger.debug(
+                        f"Connection closed during shutdown (expected): {e}"
+                    )
+                    return {'message': 'Browser shutdown (connection closed)'}
                 logger.error(f"WebSocket connection closed unexpectedly: {e}")
                 # Mark connection as closed
                 self.websocket = None
@@ -680,6 +814,8 @@ class WebSocketBrowserWrapper:
     async def type(self, ref: str, text: str) -> Dict[str, Any]:
         """Type text into an element."""
         response = await self._send_command('type', {'ref': ref, 'text': text})
+        # Log the response for debugging
+        logger.debug(f"Type response for ref {ref}: {response}")
         return response
 
     @action_logger