camel-ai 0.2.73a2__py3-none-any.whl → 0.2.73a4__py3-none-any.whl

camel/toolkits/message_integration.py

@@ -36,7 +36,7 @@ class ToolkitMessageIntegration:
         >>> # Using default message handler with toolkit
         >>> message_integration = ToolkitMessageIntegration()
         >>> search_with_messaging = message_integration.
-        add_messaging_to_toolkit(
+        register_toolkits(
         ...     SearchToolkit()
         ... )
 
@@ -44,7 +44,7 @@ class ToolkitMessageIntegration:
         >>> def search_web(query: str) -> list:
         ...     return ["result1", "result2"]
         ...
-        >>> enhanced_tools = message_integration.add_messaging_to_functions
+        >>> enhanced_tools = message_integration.register_functions
         ([search_web])
 
         >>> # Using custom message handler with different parameters
@@ -148,7 +148,7 @@ class ToolkitMessageIntegration:
         """
         return FunctionTool(self.send_message_to_user)
 
-    def add_messaging_to_toolkit(
+    def register_toolkits(
         self, toolkit: BaseToolkit, tool_names: Optional[List[str]] = None
     ) -> BaseToolkit:
         r"""Add messaging capabilities to toolkit methods.
@@ -168,26 +168,72 @@ class ToolkitMessageIntegration:
         Returns:
             The toolkit with messaging capabilities added
         """
-        original_get_tools = toolkit.get_tools
+        original_tools = toolkit.get_tools()
+        enhanced_methods = {}
+        for tool in original_tools:
+            method_name = tool.func.__name__
+            if tool_names is None or method_name in tool_names:
+                enhanced_func = self._add_messaging_to_tool(tool.func)
+                enhanced_methods[method_name] = enhanced_func
+                setattr(toolkit, method_name, enhanced_func)
+        original_get_tools_method = toolkit.get_tools
 
         def enhanced_get_tools() -> List[FunctionTool]:
-            tools = original_get_tools()
-            enhanced_tools = []
+            tools = []
+            for _, enhanced_method in enhanced_methods.items():
+                tools.append(FunctionTool(enhanced_method))
+            original_tools_list = original_get_tools_method()
+            for tool in original_tools_list:
+                if tool.func.__name__ not in enhanced_methods:
+                    tools.append(tool)
 
-            for tool in tools:
-                if tool_names is None or tool.func.__name__ in tool_names:
-                    enhanced_func = self._add_messaging_to_tool(tool.func)
-                    enhanced_tools.append(FunctionTool(enhanced_func))
-                else:
-                    enhanced_tools.append(tool)
-
-            return enhanced_tools
+            return tools
 
-        # Replace the get_tools method
         toolkit.get_tools = enhanced_get_tools  # type: ignore[method-assign]
+
+        # Also handle clone_for_new_session
+        # if it exists to ensure cloned toolkits
+        # also have message integration
+        if hasattr(toolkit, 'clone_for_new_session'):
+            original_clone_method = toolkit.clone_for_new_session
+            message_integration_instance = self
+
+            def enhanced_clone_for_new_session(new_session_id=None):
+                cloned_toolkit = original_clone_method(new_session_id)
+                return message_integration_instance.register_toolkits(
+                    cloned_toolkit, tool_names
+                )
+
+            toolkit.clone_for_new_session = enhanced_clone_for_new_session
+
         return toolkit
 
-    def add_messaging_to_functions(
+    def _create_bound_method_wrapper(
+        self, enhanced_func: Callable, toolkit_instance
+    ) -> Callable:
+        r"""Create a wrapper that mimics a bound method for _clone_tools.
+
+        This wrapper preserves the toolkit instance reference while maintaining
+        the enhanced messaging functionality.
+        """
+
+        # Create a wrapper that appears as a bound method to _clone_tools
+        @wraps(enhanced_func)
+        def bound_method_wrapper(*args, **kwargs):
+            return enhanced_func(*args, **kwargs)
+
+        # Make it appear as a bound method by setting __self__
+        bound_method_wrapper.__self__ = toolkit_instance  # type: ignore[attr-defined]
+
+        # Preserve other important attributes
+        if hasattr(enhanced_func, '__signature__'):
+            bound_method_wrapper.__signature__ = enhanced_func.__signature__  # type: ignore[attr-defined]
+        if hasattr(enhanced_func, '__doc__'):
+            bound_method_wrapper.__doc__ = enhanced_func.__doc__
+
+        return bound_method_wrapper
+
+    def register_functions(
         self,
         functions: Union[List[FunctionTool], List[Callable]],
         function_names: Optional[List[str]] = None,
@@ -210,12 +256,12 @@ class ToolkitMessageIntegration:
         Example:
             >>> # With FunctionTools
             >>> tools = [FunctionTool(search_func), FunctionTool(analyze_func)]
-            >>> enhanced_tools = message_integration.add_messaging_to_functions
+            >>> enhanced_tools = message_integration.register_functions
             (tools)
 
             >>> # With callable functions
             >>> funcs = [search_web, analyze_data, generate_report]
-            >>> enhanced_tools = message_integration.add_messaging_to_functions
+            >>> enhanced_tools = message_integration.register_functions
             (
             ...     funcs,
             ...     function_names=['search_web', 'analyze_data']
@@ -257,6 +303,9 @@ class ToolkitMessageIntegration:
         # Get the original signature
         original_sig = inspect.signature(func)
 
+        # Check if the function is async
+        is_async = inspect.iscoroutinefunction(func)
+
         # Create new parameters for the enhanced function
         new_params = list(original_sig.parameters.values())
 
@@ -321,45 +370,123 @@ class ToolkitMessageIntegration:
         # Create the new signature
         new_sig = original_sig.replace(parameters=new_params)
 
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            # Extract parameters using the callback
-            try:
-                params = self.extract_params_callback(kwargs)
-            except KeyError:
-                # If parameters are missing, just execute the original function
-                return func(*args, **kwargs)
-
-            # Check if we should send a message
-            should_send = False
-            if self.use_custom_handler:
-                should_send = any(p is not None and p != '' for p in params)
-            else:
-                # For default handler, params = (title, description,
-                # attachment)
-                should_send = bool(params[0]) or bool(params[1])
+        if is_async:
+
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                try:
+                    params = self.extract_params_callback(kwargs)
+                except KeyError:
+                    return await func(*args, **kwargs)
 
-            # Send message if needed
-            if should_send:
+                # Check if we should send a message
+                should_send = False
                 if self.use_custom_handler:
-                    self.message_handler(*params)
+                    should_send = any(
+                        p is not None and p != '' for p in params
+                    )
                 else:
-                    # For built-in handler, provide defaults
-                    title, desc, attach = params
-                    self.message_handler(
-                        title or "Executing Tool",
-                        desc or f"Running {func.__name__}",
-                        attach or '',
+                    # For default handler, params
+                    # (title, description, attachment)
+                    should_send = bool(params[0]) or bool(params[1])
+
+                # Send message if needed (handle async properly)
+                if should_send:
+                    try:
+                        if self.use_custom_handler:
+                            # Check if message handler is async
+                            if inspect.iscoroutinefunction(
+                                self.message_handler
+                            ):
+                                await self.message_handler(*params)
+                            else:
+                                self.message_handler(*params)
+                        else:
+                            # For built-in handler, provide defaults
+                            title, desc, attach = params
+                            self.message_handler(
+                                title or "Executing Tool",
+                                desc or f"Running {func.__name__}",
+                                attach or '',
+                            )
+                    except Exception as msg_error:
+                        # Don't let message handler
+                        # errors break the main function
+                        logger.warning(f"Message handler error: {msg_error}")
+
+                # Execute the original function
+                # (kwargs have been modified to remove message params)
+                result = await func(*args, **kwargs)
+
+                return result
+        else:
+
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                # Extract parameters using the callback
+                # (this will modify kwargs by removing message params)
+                try:
+                    params = self.extract_params_callback(kwargs)
+                except KeyError:
+                    # If parameters are missing,
+                    # just execute the original function
+                    return func(*args, **kwargs)
+
+                # Check if we should send a message
+                should_send = False
+                if self.use_custom_handler:
+                    should_send = any(
+                        p is not None and p != '' for p in params
                     )
+                else:
+                    should_send = bool(params[0]) or bool(params[1])
 
-            # Execute the original function
-            result = func(*args, **kwargs)
+                # Send message if needed
+                if should_send:
+                    try:
+                        if self.use_custom_handler:
+                            self.message_handler(*params)
+                        else:
+                            # For built-in handler, provide defaults
+                            title, desc, attach = params
+                            self.message_handler(
+                                title or "Executing Tool",
+                                desc or f"Running {func.__name__}",
+                                attach or '',
+                            )
+                    except Exception as msg_error:
+                        logger.warning(f"Message handler error: {msg_error}")
+
+                result = func(*args, **kwargs)
 
-            return result
+                return result
 
         # Apply the new signature to the wrapper
         wrapper.__signature__ = new_sig  # type: ignore[attr-defined]
 
+        # Create a hybrid approach:
+        # store toolkit instance info but preserve calling behavior
+        # We'll use a property-like
+        # approach to make __self__ available when needed
+        if hasattr(func, '__self__'):
+            toolkit_instance = func.__self__
+
+            # Store the toolkit instance as an attribute
+            # Use setattr to avoid MyPy type checking issues
+            wrapper.__toolkit_instance__ = toolkit_instance  # type: ignore[attr-defined]
+
+            # Create a dynamic __self__ property
+            # that only appears during introspection
+            # but doesn't interfere with normal function calls
+            def get_self():
+                return toolkit_instance
+
+            # Only set __self__
+            # if we're being called in an introspection context
+            # (like from _clone_tools)
+            # Use setattr to avoid MyPy type checking issues
+            wrapper.__self__ = toolkit_instance  # type: ignore[attr-defined]
+
         # Enhance the docstring
         if func.__doc__:
             enhanced_doc = func.__doc__.rstrip()

camel/toolkits/web_deploy_toolkit.py

@@ -79,7 +79,9 @@ class WebDeployToolkit(BaseToolkit):
         self.tag_text = self._sanitize_text(tag_text)
         self.tag_url = self._validate_url(tag_url)
         self.remote_server_ip = (
-            self._validate_ip(remote_server_ip) if remote_server_ip else None
+            self._validate_ip_or_domain(remote_server_ip)
+            if remote_server_ip
+            else None
         )
         self.remote_server_port = self._validate_port(remote_server_port)
         self.server_registry_file = os.path.join(
@@ -87,24 +89,36 @@ class WebDeployToolkit(BaseToolkit):
         )
         self._load_server_registry()
 
-    def _validate_ip(self, ip: str) -> str:
-        """Validate IP address format."""
+    def _validate_ip_or_domain(self, address: str) -> str:
+        r"""Validate IP address or domain name format."""
         import ipaddress
+        import re
 
         try:
-            ipaddress.ip_address(ip)
-            return ip
+            # Try to validate as IP address first
+            ipaddress.ip_address(address)
+            return address
         except ValueError:
-            raise ValueError(f"Invalid IP address: {ip}")
+            # If not a valid IP, check if it's a valid domain name
+            domain_pattern = re.compile(
+                r'^[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?'
+                r'(\.[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?)*$'
+            )
+            if domain_pattern.match(address) and len(address) <= 253:
+                return address
+            else:
+                raise ValueError(
+                    f"Invalid IP address or domain name: {address}"
+                )
 
     def _validate_port(self, port: int) -> int:
-        """Validate port number."""
+        r"""Validate port number."""
         if not isinstance(port, int) or port < 1 or port > 65535:
             raise ValueError(f"Invalid port number: {port}")
         return port
 
     def _sanitize_text(self, text: str) -> str:
-        """Sanitize text to prevent XSS."""
+        r"""Sanitize text to prevent XSS."""
         if not isinstance(text, str):
             return ""
         # Remove any HTML/script tags
@@ -119,7 +133,7 @@ class WebDeployToolkit(BaseToolkit):
         return text[:100]  # Limit length
 
     def _validate_url(self, url: str) -> str:
-        """Validate URL format."""
+        r"""Validate URL format."""
         if not isinstance(url, str):
             raise ValueError("URL must be a string")
         # Basic URL validation
@@ -139,7 +153,7 @@ class WebDeployToolkit(BaseToolkit):
     def _validate_subdirectory(
         self, subdirectory: Optional[str]
     ) -> Optional[str]:
-        """Validate subdirectory to prevent path traversal."""
+        r"""Validate subdirectory to prevent path traversal."""
         if subdirectory is None:
             return None
 
@@ -157,7 +171,7 @@ class WebDeployToolkit(BaseToolkit):
         return subdirectory
 
     def _is_port_available(self, port: int) -> bool:
-        """Check if a port is available for binding."""
+        r"""Check if a port is available for binding."""
         with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
             try:
                 sock.bind(('127.0.0.1', port))
@@ -604,7 +618,7 @@ class WebDeployToolkit(BaseToolkit):
                 return {
                     'success': False,
                     'error': (
-                        f'Port {port} is already in use by ' f'another process'
+                        f'Port {port} is already in use by another process'
                     ),
                 }
 
@@ -702,6 +716,44 @@ class WebDeployToolkit(BaseToolkit):
             # Validate subdirectory
             subdirectory = self._validate_subdirectory(subdirectory)
 
+            # Check if remote deployment is configured
+            if self.remote_server_ip:
+                return self._deploy_folder_to_remote_server(
+                    folder_path,
+                    subdirectory,
+                    domain,
+                )
+            else:
+                return self._deploy_folder_to_local_server(
+                    folder_path,
+                    port,
+                    domain,
+                    subdirectory,
+                )
+
+        except Exception as e:
+            logger.error(f"Error deploying folder: {e}")
+            return {'success': False, 'error': str(e)}
+
+    def _deploy_folder_to_local_server(
+        self,
+        folder_path: str,
+        port: int,
+        domain: Optional[str],
+        subdirectory: Optional[str],
+    ) -> Dict[str, Any]:
+        r"""Deploy folder to local server (original functionality).
+
+        Args:
+            folder_path (str): Path to the folder to deploy
+            port (int): Port to serve on
+            domain (Optional[str]): Custom domain
+            subdirectory (Optional[str]): Subdirectory path
+
+        Returns:
+            Dict[str, Any]: Deployment result
+        """
+        try:
             temp_dir = None
             if self.add_branding_tag:
                 # Create temporary directory and copy all files
@@ -877,6 +929,149 @@ class WebDeployToolkit(BaseToolkit):
             logger.error(f"Error deploying folder: {e}")
             return {'success': False, 'error': str(e)}
 
+    def _deploy_folder_to_remote_server(
+        self,
+        folder_path: str,
+        subdirectory: Optional[str] = None,
+        domain: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        r"""Deploy folder to remote server via API.
+
+        Args:
+            folder_path (str): Path to the folder to deploy
+            subdirectory (Optional[str]): Subdirectory path for deployment
+            domain (Optional[str]): Custom domain
+
+        Returns:
+            Dict[str, Any]: Deployment result
+        """
+        try:
+            import tempfile
+            import zipfile
+
+            import requests
+
+            # Validate subdirectory
+            subdirectory = self._validate_subdirectory(subdirectory)
+
+            # Create a temporary zip file of the folder
+            with tempfile.NamedTemporaryFile(
+                suffix='.zip', delete=False
+            ) as temp_zip:
+                zip_path = temp_zip.name
+
+            try:
+                # Create zip archive
+                with zipfile.ZipFile(
+                    zip_path, 'w', zipfile.ZIP_DEFLATED
+                ) as zipf:
+                    for root, _, files in os.walk(folder_path):
+                        for file in files:
+                            file_path = os.path.join(root, file)
+                            # Calculate relative path within the archive
+                            arcname = os.path.relpath(file_path, folder_path)
+                            zipf.write(file_path, arcname)
+
+                # Read zip file as base64
+                with open(zip_path, 'rb') as f:
+                    zip_data = base64.b64encode(f.read()).decode('utf-8')
+
+                # Prepare deployment data
+                deploy_data = {
+                    "deployment_type": "folder",
+                    "folder_data": zip_data,
+                    "subdirectory": subdirectory,
+                    "domain": domain,
+                    "timestamp": time.time(),
+                }
+
+                # Add logo data if custom logo is specified
+                if self.logo_path and os.path.exists(self.logo_path):
+                    try:
+                        logo_ext = os.path.splitext(self.logo_path)[1]
+                        logo_filename = f"custom_logo{logo_ext}"
+
+                        with open(self.logo_path, 'rb') as logo_file:
+                            logo_data = base64.b64encode(
+                                logo_file.read()
+                            ).decode('utf-8')
+
+                        deploy_data.update(
+                            {
+                                "logo_data": logo_data,
+                                "logo_ext": logo_ext,
+                                "logo_filename": logo_filename,
+                            }
+                        )
+                    except Exception as logo_error:
+                        logger.warning(
+                            f"Failed to process custom logo: {logo_error}"
+                        )
+
+                # Send to remote server API
+                api_url = f"http://{self.remote_server_ip}:{self.remote_server_port}/api/deploy"
+
+                response = requests.post(
+                    api_url,
+                    json=deploy_data,
+                    timeout=self.timeout
+                    or 60,  # Extended timeout for folder uploads
+                    allow_redirects=False,
+                    headers={'Content-Type': 'application/json'},
+                )
+
+                if response.status_code == 200:
+                    result = response.json()
+
+                    # Build URLs
+                    base_url = f"http://{self.remote_server_ip}:{self.remote_server_port}"
+                    deployed_url = (
+                        f"{base_url}/{subdirectory}/"
+                        if subdirectory
+                        else base_url
+                    )
+
+                    return {
+                        'success': True,
+                        'remote_url': deployed_url,
+                        'server_ip': self.remote_server_ip,
+                        'subdirectory': subdirectory,
+                        'domain': domain,
+                        'message': (
+                            f'Successfully deployed folder to remote server!\n'
+                            f'  • Access URL: {deployed_url}\n'
+                            f'  • Server: '
+                            f'{self.remote_server_ip}:{self.remote_server_port}'
+                        ),
+                        'branding_tag_added': self.add_branding_tag,
+                        'logo_processed': result.get('logo_processed', False),
+                    }
+                else:
+                    return {
+                        'success': False,
+                        'error': (
+                            f'Remote folder deployment failed: '
+                            f'HTTP {response.status_code}'
+                        ),
+                    }
+
+            finally:
+                # Clean up temporary zip file
+                if os.path.exists(zip_path):
+                    os.unlink(zip_path)
+
+        except ImportError:
+            return {
+                'success': False,
+                'error': 'Remote deployment requires requests library. '
+                'Install with: pip install requests',
+            }
+        except Exception as e:
+            return {
+                'success': False,
+                'error': f'Remote folder deployment error: {e!s}',
+            }
+
     def stop_server(self, port: int) -> Dict[str, Any]:
         r"""Stop a running server on the specified port.
 

{camel_ai-0.2.73a2.dist-info → camel_ai-0.2.73a4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.73a2
+Version: 0.2.73a4
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -124,6 +124,7 @@ Requires-Dist: slack-bolt<2,>=1.20.1; extra == 'all'
 Requires-Dist: slack-sdk<4,>=3.27.2; extra == 'all'
 Requires-Dist: soundfile<0.14,>=0.13; extra == 'all'
 Requires-Dist: stripe<12,>=11.3.0; extra == 'all'
+Requires-Dist: surrealdb>=1.0.6; extra == 'all'
 Requires-Dist: sympy<2,>=1.13.3; extra == 'all'
 Requires-Dist: tabulate>=0.9.0; extra == 'all'
 Requires-Dist: tavily-python<0.6,>=0.5.0; extra == 'all'
@@ -336,6 +337,7 @@ Requires-Dist: pyobvector>=0.1.18; extra == 'storage'
 Requires-Dist: pytidb-experimental==0.0.1.dev4; extra == 'storage'
 Requires-Dist: qdrant-client<2,>=1.9.0; extra == 'storage'
 Requires-Dist: redis<6,>=5.0.6; extra == 'storage'
+Requires-Dist: surrealdb>=1.0.6; extra == 'storage'
 Requires-Dist: weaviate-client>=4.15.0; extra == 'storage'
 Provides-Extra: web-tools
 Requires-Dist: apify-client<2,>=1.8.1; extra == 'web-tools'