camel-ai 0.2.69a3__tar.gz → 0.2.69a6__tar.gz

{camel_ai-0.2.69a3 → camel_ai-0.2.69a6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.69a3
+Version: 0.2.69a6
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -176,7 +176,7 @@ Requires-Dist: types-pyyaml<7,>=6.0.12; extra == 'dev'
 Requires-Dist: types-requests<3,>=2.31.0; extra == 'dev'
 Requires-Dist: types-setuptools<70,>=69.2.0; extra == 'dev'
 Requires-Dist: types-tqdm<5,>=4.66.0; extra == 'dev'
-Requires-Dist: uv==0.6.5; extra == 'dev'
+Requires-Dist: uv<0.8,>=0.7.0; extra == 'dev'
 Provides-Extra: dev-tools
 Requires-Dist: aci-sdk>=1.0.0b1; extra == 'dev-tools'
 Requires-Dist: agentops<0.4,>=0.3.21; extra == 'dev-tools'
@@ -322,10 +322,6 @@ 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: weaviate-client>=4.15.0; extra == 'storage'
-Provides-Extra: test
-Requires-Dist: mock<6,>=5; extra == 'test'
-Requires-Dist: pytest-asyncio<0.24,>=0.23.0; extra == 'test'
-Requires-Dist: pytest<8,>=7; extra == 'test'
 Provides-Extra: web-tools
 Requires-Dist: apify-client<2,>=1.8.1; extra == 'web-tools'
 Requires-Dist: beautifulsoup4<5,>=4; extra == 'web-tools'

{camel_ai-0.2.69a3 → camel_ai-0.2.69a6}/camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.69a3'
+__version__ = '0.2.69a6'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.69a3 → camel_ai-0.2.69a6}/camel/agents/chat_agent.py

@@ -1904,36 +1904,12 @@ class ChatAgent(BaseAgent):
             ChatAgent: A new instance of :obj:`ChatAgent` with the same
                 configuration.
         """
-        import copy
-
         # Create a new instance with the same configuration
         # If with_memory is True, set system_message to None
         # If with_memory is False, use the original system message
         # To avoid duplicated system memory.
         system_message = None if with_memory else self._original_system_message
 
-        # Create deep copies of tools to avoid shared state
-        cloned_tools: List[Union[FunctionTool, Callable]] = []
-        for tool in self._internal_tools.values():
-            # Create a new FunctionTool instance to avoid sharing state
-            cloned_tool = copy.deepcopy(tool)
-            cloned_tools.append(cloned_tool)
-
-        # Create deep copies of external tool schemas
-        cloned_external_tools: List[
-            Union[FunctionTool, Callable, Dict[str, Any]]
-        ] = []
-        for schema in self._external_tool_schemas.values():
-            cloned_schema = copy.deepcopy(schema)
-            cloned_external_tools.append(cloned_schema)
-
-        # Create deep copies of response terminators to avoid shared state
-        cloned_terminators: List[ResponseTerminator] = []
-        if self.response_terminators:
-            for terminator in self.response_terminators:
-                cloned_terminator = copy.deepcopy(terminator)
-                cloned_terminators.append(cloned_terminator)
-
         new_agent = ChatAgent(
             system_message=system_message,
             model=self.model_backend.models,  # Pass the existing model_backend
@@ -1943,9 +1919,11 @@ class ChatAgent(BaseAgent):
                 self.memory.get_context_creator(), "token_limit", None
             ),
             output_language=self._output_language,
-            tools=cloned_tools,
-            external_tools=cloned_external_tools,
-            response_terminators=cloned_terminators,
+            tools=[tool.func for tool in self._internal_tools.values()],
+            external_tools=[
+                schema for schema in self._external_tool_schemas.values()
+            ],
+            response_terminators=self.response_terminators,
             scheduling_strategy=self.model_backend.scheduling_strategy.__name__,
             max_iteration=self.max_iteration,
             stop_event=self.stop_event,

{camel_ai-0.2.69a3 → camel_ai-0.2.69a6}/camel/interpreters/internal_python_interpreter.py

@@ -79,6 +79,9 @@ class InternalPythonInterpreter(BaseInterpreter):
             (default: :obj:`False`)
         raise_error (bool, optional): Raise error if the interpreter fails.
             (default: :obj:`False`)
+        allow_builtins (bool, optional): If `True`, safe built-in functions
+            like print, len, str, etc. are added to the action space.
+            (default: :obj:`True`)
     """
 
     _CODE_TYPES: ClassVar[List[str]] = ["python", "py", "python3", "python2"]
@@ -89,16 +92,62 @@ class InternalPythonInterpreter(BaseInterpreter):
         import_white_list: Optional[List[str]] = None,
         unsafe_mode: bool = False,
         raise_error: bool = False,
+        allow_builtins: bool = True,
     ) -> None:
         self.action_space = action_space or dict()
-        # Add print to action space
-        self.action_space['print'] = print
         self.state = self.action_space.copy()
         self.fuzz_state: Dict[str, Any] = dict()
         self.import_white_list = import_white_list or list()
         self.raise_error = raise_error
         self.unsafe_mode = unsafe_mode
 
+        # Add safe built-in functions if allowed
+        if allow_builtins:
+            self._add_safe_builtins()
+
+    def _add_safe_builtins(self):
+        r"""Add safe built-in functions to the action space."""
+        safe_builtins = {
+            'print': print,
+            'len': len,
+            'str': str,
+            'int': int,
+            'float': float,
+            'bool': bool,
+            'list': list,
+            'dict': dict,
+            'tuple': tuple,
+            'set': set,
+            'abs': abs,
+            'min': min,
+            'max': max,
+            'sum': sum,
+            'sorted': sorted,
+            'reversed': reversed,
+            'enumerate': enumerate,
+            'zip': zip,
+            'range': range,
+            'round': round,
+            'type': type,
+            'isinstance': isinstance,
+            'hasattr': hasattr,
+            'getattr': getattr,
+            'setattr': setattr,
+            'dir': dir,
+            'help': help,
+            'map': map,
+            'filter': filter,
+            'any': any,
+            'all': all,
+            'ord': ord,
+            'chr': chr,
+            'bin': bin,
+            'oct': oct,
+            'hex': hex,
+        }
+        self.action_space.update(safe_builtins)
+        self.state.update(safe_builtins)
+
     def run(self, code: str, code_type: str = "python") -> str:
         r"""Executes the given code with specified code type in the
         interpreter.

{camel_ai-0.2.69a3 → camel_ai-0.2.69a6}/camel/models/base_model.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import abc
+import os
 import re
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Type, Union
@@ -94,6 +95,12 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         self._token_counter = token_counter
         self._timeout = timeout
         self._max_retries = max_retries
+        # Initialize logging configuration
+        self._log_enabled = (
+            os.environ.get("CAMEL_MODEL_LOG_ENABLED", "False").lower()
+            == "true"
+        )
+        self._log_dir = os.environ.get("CAMEL_LOG_DIR", "camel_logs")
         self.check_model_config()
 
     @property
@@ -232,6 +239,68 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
 
         return formatted_messages
 
+    def _log_request(self, messages: List[OpenAIMessage]) -> Optional[str]:
+        r"""Log the request messages to a JSON file if logging is enabled.
+
+        Args:
+            messages (List[OpenAIMessage]): The messages to log.
+
+        Returns:
+            Optional[str]: The path to the log file if logging is enabled,
+                None otherwise.
+        """
+        if not self._log_enabled:
+            return None
+
+        import json
+        from datetime import datetime
+
+        os.makedirs(self._log_dir, exist_ok=True)
+
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S_%f')
+        log_file_path = os.path.join(self._log_dir, f"conv_{timestamp}.json")
+
+        log_entry = {
+            "request_timestamp": datetime.now().isoformat(),
+            "model": str(self.model_type),
+            "request": {"messages": messages},
+        }
+
+        with open(log_file_path, "w") as f:
+            json.dump(log_entry, f, indent=4)
+
+        return log_file_path
+
+    def _log_response(self, log_path: str, response: Any) -> None:
+        r"""Log the response to the existing log file.
+
+        Args:
+            log_path (str): The path to the log file.
+            response (Any): The response to log.
+        """
+        if not self._log_enabled or not log_path:
+            return
+
+        import json
+        from datetime import datetime
+
+        with open(log_path, "r+") as f:
+            log_data = json.load(f)
+
+            log_data["response_timestamp"] = datetime.now().isoformat()
+            if isinstance(response, BaseModel):
+                log_data["response"] = response.model_dump()
+            else:
+                try:
+                    json.dumps(response)
+                    log_data["response"] = response
+                except TypeError:
+                    log_data["response"] = str(response)
+
+            f.seek(0)
+            json.dump(log_data, f, indent=4)
+            f.truncate()
+
     @abstractmethod
     def _run(
         self,
@@ -273,13 +342,23 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
+        # Log the request if logging is enabled
+        log_path = self._log_request(messages)
+
         # None -> use default tools
         if tools is None:
             tools = self.model_config_dict.get("tools", None)
         # Empty -> use no tools
         elif not tools:
             tools = None
-        return self._run(messages, response_format, tools)
+
+        result = self._run(messages, response_format, tools)
+
+        # Log the response if logging is enabled
+        if log_path:
+            self._log_response(log_path, result)
+
+        return result
 
     async def arun(
         self,
@@ -304,11 +383,21 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
+        # Log the request if logging is enabled
+        log_path = self._log_request(messages)
+
         if tools is None:
             tools = self.model_config_dict.get("tools", None)
         elif not tools:
             tools = None
-        return await self._arun(messages, response_format, tools)
+
+        result = await self._arun(messages, response_format, tools)
+
+        # Log the response if logging is enabled
+        if log_path:
+            self._log_response(log_path, result)
+
+        return result
 
     @abstractmethod
     def check_model_config(self):

{camel_ai-0.2.69a3 → camel_ai-0.2.69a6}/camel/societies/workforce/single_agent_worker.py

@@ -284,6 +284,13 @@ class SingleAgentWorker(Worker):
             response = await worker_agent.astep(
                 prompt, response_format=TaskResult
             )
+
+            # Get token usage from the response
+            usage_info = response.info.get("usage") or response.info.get(
+                "token_usage"
+            )
+            total_tokens = usage_info.get("total_tokens", 0)
+
         except Exception as e:
             print(
                 f"{Fore.RED}Error processing task {task.id}: "
@@ -294,13 +301,6 @@ class SingleAgentWorker(Worker):
             # Return agent to pool or let it be garbage collected
             await self._return_worker_agent(worker_agent)
 
-        # Get actual token usage from the agent that processed this task
-        try:
-            _, total_token_count = worker_agent.memory.get_context()
-        except Exception:
-            # Fallback if memory context unavailable
-            total_token_count = 0
-
         # Populate additional_info with worker attempt details
         if task.additional_info is None:
             task.additional_info = {}
@@ -321,7 +321,7 @@ class SingleAgentWorker(Worker):
             f"to process task {task.content}",
             "response_content": response.msg.content,
             "tool_calls": response.info.get("tool_calls"),
-            "total_token_count": total_token_count,
+            "total_tokens": total_tokens,
         }
 
         # Store the worker attempt in additional_info
@@ -330,9 +330,7 @@ class SingleAgentWorker(Worker):
         task.additional_info["worker_attempts"].append(worker_attempt_details)
 
         # Store the actual token usage for this specific task
-        task.additional_info["token_usage"] = {
-            "total_tokens": total_token_count
-        }
+        task.additional_info["token_usage"] = {"total_tokens": total_tokens}
 
         print(f"======\n{Fore.GREEN}Reply from {self}:{Fore.RESET}")
 

{camel_ai-0.2.69a3 → camel_ai-0.2.69a6}/camel/toolkits/__init__.py

@@ -78,6 +78,9 @@ from .playwright_mcp_toolkit import PlaywrightMCPToolkit
 from .wolfram_alpha_toolkit import WolframAlphaToolkit
 from .task_planning_toolkit import TaskPlanningToolkit
 from .non_visual_browser_toolkit import BrowserNonVisualToolkit
+from .edgeone_pages_mcp_toolkit import EdgeOnePagesMCPToolkit
+from .craw4ai_toolkit import Crawl4AIToolkit
+from .markitdown_toolkit import MarkItDownToolkit
 
 
 __all__ = [
@@ -144,4 +147,7 @@ __all__ = [
     'BohriumToolkit',
     'TaskPlanningToolkit',
     'BrowserNonVisualToolkit',
+    'EdgeOnePagesMCPToolkit',
+    'Crawl4AIToolkit',
+    'MarkItDownToolkit',
 ]

camel_ai-0.2.69a6/camel/toolkits/craw4ai_toolkit.py

@@ -0,0 +1,73 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+from typing import List, Optional
+
+from camel.logger import get_logger
+from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+from camel.utils import MCPServer
+
+logger = get_logger(__name__)
+
+
+@MCPServer()
+class Crawl4AIToolkit(BaseToolkit):
+    r"""A class representing a toolkit for Crawl4AI."""
+
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ):
+        super().__init__(timeout=timeout)
+
+    async def scrape(self, url: str) -> str:
+        r"""Scrapes a webpage and returns its content.
+
+        This function is designed to fetch the content of a given URL and
+        return it as a single string. It's particularly useful for extracting
+        text from web pages for further processing. The function
+        will try to get the most meaningful content from the page.
+
+        Args:
+            url (str): The URL of the webpage to scrape.
+
+        Returns:
+            str: The scraped content of the webpage as a string. If the
+                scraping fails, it will return an error message.
+        """
+        from crawl4ai import AsyncWebCrawler, CrawlerRunConfig
+
+        try:
+            async with AsyncWebCrawler() as client:
+                config = CrawlerRunConfig(
+                    only_text=True,
+                )
+                content = await client.arun(url, crawler_config=config)
+                return str(content.markdown) if content.markdown else ""
+        except Exception as e:
+            logger.error(f"Error scraping {url}: {e}")
+            return f"Error scraping {url}: {e}"
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of FunctionTool objects representing the
+        functions in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of FunctionTool objects
+                representing the functions in the toolkit.
+        """
+        return [
+            FunctionTool(self.scrape),
+        ]

camel_ai-0.2.69a6/camel/toolkits/edgeone_pages_mcp_toolkit.py

@@ -0,0 +1,69 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+from typing import List, Optional
+
+from camel.toolkits import BaseToolkit, FunctionTool
+
+from .mcp_toolkit import MCPToolkit
+
+
+class EdgeOnePagesMCPToolkit(BaseToolkit):
+    r"""EdgeOnePagesMCPToolkit provides an interface for interacting with
+    EdgeOne pages using the EdgeOne Pages MCP server.
+
+    Attributes:
+        timeout (Optional[float]): Connection timeout in seconds.
+            (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ) -> None:
+        r"""Initializes the EdgeOnePagesMCPToolkit.
+
+        Args:
+            timeout (Optional[float]): Connection timeout in seconds.
+                (default: :obj:`None`)
+        """
+        super().__init__(timeout=timeout)
+
+        self._mcp_toolkit = MCPToolkit(
+            config_dict={
+                "mcpServers": {
+                    "edgeone-pages-mcp-server": {
+                        "command": "npx",
+                        "args": ["edgeone-pages-mcp"],
+                    }
+                }
+            },
+            timeout=timeout,
+        )
+
+    async def connect(self):
+        r"""Explicitly connect to the EdgeOne Pages MCP server."""
+        await self._mcp_toolkit.connect()
+
+    async def disconnect(self):
+        r"""Explicitly disconnect from the EdgeOne Pages MCP server."""
+        await self._mcp_toolkit.disconnect()
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of tools provided by the EdgeOnePagesMCPToolkit.
+
+        Returns:
+            List[FunctionTool]: List of available tools.
+        """
+        return self._mcp_toolkit.get_tools()

camel_ai-0.2.69a6/camel/toolkits/markitdown_toolkit.py

@@ -0,0 +1,78 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+from typing import Dict, List, Optional
+
+from camel.loaders.markitdown import MarkItDownLoader
+from camel.logger import get_logger
+from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+from camel.utils import MCPServer
+
+logger = get_logger(__name__)
+
+
+@MCPServer()
+class MarkItDownToolkit(BaseToolkit):
+    r"""A class representing a toolkit for MarkItDown."""
+
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ):
+        super().__init__(timeout=timeout)
+
+    def load_files(self, file_paths: List[str]) -> Dict[str, str]:
+        r"""Scrapes content from a list of files and converts it to Markdown.
+
+        This function takes a list of local file paths, attempts to convert
+        each file into Markdown format, and returns the converted content.
+        The conversion is performed in parallel for efficiency.
+
+        Supported file formats include:
+        - PDF (.pdf)
+        - Microsoft Office: Word (.doc, .docx), Excel (.xls, .xlsx),
+          PowerPoint (.ppt, .pptx)
+        - EPUB (.epub)
+        - HTML (.html, .htm)
+        - Images (.jpg, .jpeg, .png) for OCR
+        - Audio (.mp3, .wav) for transcription
+        - Text-based formats (.csv, .json, .xml, .txt)
+        - ZIP archives (.zip)
+
+        Args:
+            file_paths (List[str]): A list of local file paths to be
+                converted.
+
+        Returns:
+            Dict[str, str]: A dictionary where keys are the input file paths
+                and values are the corresponding content in Markdown format.
+                If conversion of a file fails, the value will contain an
+                error message.
+        """
+        return MarkItDownLoader().convert_files(
+            file_paths=file_paths, parallel=True
+        )
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of FunctionTool objects representing the
+        functions in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of FunctionTool objects
+                representing the functions in the toolkit.
+        """
+        return [
+            FunctionTool(self.load_files),
+        ]