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

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,12 @@ 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._browser_opened = False
+        self._server_ready_future = None
+
         self.browser_log_to_file = (config or {}).get(
             'browser_log_to_file', False
         )
@@ -127,10 +120,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 +131,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,13 +145,61 @@ 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()
+
+        import platform
+
+        use_shell = platform.system() == 'Windows'
         npm_check = subprocess.run(
             ['npm', '--version'],
             capture_output=True,
             text=True,
+            shell=use_shell,
         )
         if npm_check.returncode != 0:
             raise RuntimeError(
@@ -169,11 +208,11 @@ class WebSocketBrowserWrapper:
                 "to use the hybrid browser toolkit."
             )
 
-        # Check if node is installed
         node_check = subprocess.run(
             ['node', '--version'],
             capture_output=True,
             text=True,
+            shell=use_shell,
         )
         if node_check.returncode != 0:
             raise RuntimeError(
@@ -182,7 +221,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...")
@@ -191,6 +229,7 @@ class WebSocketBrowserWrapper:
                 cwd=self.ts_dir,
                 capture_output=True,
                 text=True,
+                shell=use_shell,
             )
             if install_result.returncode != 0:
                 logger.error(f"npm install failed: {install_result.stderr}")
@@ -200,12 +239,12 @@ 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,
             capture_output=True,
             text=True,
+            shell=use_shell,
         )
         if build_result.returncode != 0:
             logger.error(f"TypeScript build failed: {build_result.stderr}")
@@ -213,20 +252,20 @@ class WebSocketBrowserWrapper:
                 f"TypeScript build failed: {build_result.stderr}"
             )
 
-        # Start the WebSocket server
+        # use_shell already defined above
         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
+            encoding='utf-8',
+            bufsize=1,
+            shell=use_shell,
         )
 
-        # 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 +276,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 +289,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 +304,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 +314,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,45 +381,45 @@ 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)
 
+        if self.config.get('cdpUrl'):
+            self._browser_opened = True
+
     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):
                 await self.websocket.close()
             self.websocket = None
 
+        self._browser_opened = False
+
         # Gracefully stop the Node process before cancelling the log reader
         if self.process:
             try:
@@ -381,6 +458,54 @@ 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.
+        """
+        if self.websocket:
+            with contextlib.suppress(Exception):
+                await self.websocket.close()
+            self.websocket = None
+
+        self._browser_opened = False
+
+        # 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 +579,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 +605,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 +628,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 +676,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 +699,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
@@ -575,17 +725,31 @@ class WebSocketBrowserWrapper:
         response = await self._send_command(
             'open_browser', {'startUrl': start_url}
         )
+        self._browser_opened = True
         return response
 
     @action_logger
     async def close_browser(self) -> str:
         """Close browser."""
         response = await self._send_command('close_browser', {})
+        self._browser_opened = False
         return response['message']
 
     @action_logger
     async def visit_page(self, url: str) -> Dict[str, Any]:
-        """Visit a page."""
+        """Visit a page.
+
+        In non-CDP mode, automatically opens browser if not already open.
+        """
+        if not self._browser_opened:
+            is_cdp_mode = bool(self.config.get('cdpUrl'))
+
+            if not is_cdp_mode:
+                logger.info(
+                    "Browser not open, automatically opening browser..."
+                )
+                await self.open_browser()
+
         response = await self._send_command('visit_page', {'url': url})
         return response
 
@@ -680,6 +844,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

camel/toolkits/hybrid_browser_toolkit_py/hybrid_browser_toolkit.py

@@ -92,12 +92,12 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
         user_data_dir: Optional[str] = None,
         stealth: bool = False,
         web_agent_model: Optional[BaseModelBackend] = None,
-        cache_dir: str = "tmp/",
+        cache_dir: Optional[str] = None,
         enabled_tools: Optional[List[str]] = None,
         browser_log_to_file: bool = False,
         log_dir: Optional[str] = None,
         session_id: Optional[str] = None,
-        default_start_url: str = "https://google.com/",
+        default_start_url: Optional[str] = None,
         default_timeout: Optional[int] = None,
         short_timeout: Optional[int] = None,
         navigation_timeout: Optional[int] = None,
@@ -202,10 +202,10 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
         self._user_data_dir = user_data_dir
         self._stealth = stealth
         self._web_agent_model = web_agent_model
-        self._cache_dir = cache_dir
+        self._cache_dir = cache_dir or "tmp/"
         self._browser_log_to_file = browser_log_to_file
         self._log_dir = log_dir
-        self._default_start_url = default_start_url
+        self._default_start_url = default_start_url or "https://google.com/"
         self._session_id = session_id or "default"
         self._viewport_limit = viewport_limit
 

camel/toolkits/markitdown_toolkit.py

@@ -25,12 +25,38 @@ logger = get_logger(__name__)
 
 @MCPServer()
 class MarkItDownToolkit(BaseToolkit):
-    r"""A class representing a toolkit for MarkItDown."""
+    r"""A class representing a toolkit for MarkItDown.
+
+    .. deprecated::
+        MarkItDownToolkit is deprecated. Use FileToolkit instead, which now
+        includes the same functionality through its read_file method that
+        supports both single files and multiple files.
+
+        Example migration:
+            # Old way
+            from camel.toolkits import MarkItDownToolkit
+            toolkit = MarkItDownToolkit()
+            content = toolkit.read_files(['file1.pdf', 'file2.docx'])
+
+            # New way
+            from camel.toolkits import FileToolkit
+            toolkit = FileToolkit()
+            content = toolkit.read_file(['file1.pdf', 'file2.docx'])
+    """
 
     def __init__(
         self,
         timeout: Optional[float] = None,
     ):
+        import warnings
+
+        warnings.warn(
+            "MarkItDownToolkit is deprecated and will be removed in a future "
+            "version. Please use FileToolkit instead, which now includes "
+            "read_file method that supports both single and multiple files.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         super().__init__(timeout=timeout)
 
     def read_files(self, file_paths: List[str]) -> Dict[str, str]:

camel/toolkits/note_taking_toolkit.py

@@ -138,33 +138,43 @@ class NoteTakingToolkit(BaseToolkit):
             self.registry.append(note_name)
             self._save_registry()
 
-    def create_note(self, note_name: str, content: str) -> str:
+    def create_note(
+        self, note_name: str, content: str, overwrite: bool = False
+    ) -> str:
         r"""Creates a new note with a unique name.
 
         This function will create a new file for your note.
-        You must provide a `note_name` that does not already exist. If you want
-        to add content to an existing note, use the `append_note` function
-        instead.
+        By default, you must provide a `note_name` that does not already exist.
+        If you want to add content to an existing note, use the `append_note`
+        function instead. If you want to overwrite an existing note, set
+        `overwrite=True`.
 
         Args:
             note_name (str): The name for your new note (without the .md
-                extension). This name must be unique.
+                extension). This name must be unique unless overwrite is True.
             content (str): The initial content to write in the note.
+            overwrite (bool): Whether to overwrite an existing note.
+                Defaults to False.
 
         Returns:
             str: A message confirming the creation of the note or an error if
-                the note name is not valid or already exists.
+                the note name is not valid or already exists
+                (when overwrite=False).
         """
         try:
             note_path = self.working_directory / f"{note_name}.md"
+            existed_before = note_path.exists()
 
-            if note_path.exists():
+            if existed_before and not overwrite:
                 return f"Error: Note '{note_name}.md' already exists."
 
             note_path.write_text(content, encoding="utf-8")
             self._register_note(note_name)
 
-            return f"Note '{note_name}.md' successfully created."
+            if existed_before and overwrite:
+                return f"Note '{note_name}.md' successfully overwritten."
+            else:
+                return f"Note '{note_name}.md' successfully created."
         except Exception as e:
             return f"Error creating note: {e}"