camel-ai 0.2.69a7__py3-none-any.whl → 0.2.70__py3-none-any.whl

camel/__init__.py

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

camel/societies/role_playing.py

@@ -556,13 +556,12 @@ class RolePlaying:
             )
         user_msg = self._reduce_message_options(user_response.msgs)
 
-        # To prevent recording the same memory more than once (once in chat
-        # step and once in role play), and the model generates only one
-        # response when multi-response support is enabled.
-        if (
-            'n' in self.user_agent.model_backend.model_config_dict.keys()
-            and self.user_agent.model_backend.model_config_dict['n'] > 1
-        ):
+        # To prevent recording missing messages: ChatAgent.step automatically
+        # saves the response to memory only when a single message is returned.
+        # When multi-response support is enabled (n > 1), it is the caller's
+        # responsibility to record the selected message. Therefore, we record
+        # it here after choosing one message via `_reduce_message_options()`.
+        if self._is_multi_response(self.user_agent):
             self.user_agent.record_message(user_msg)
 
         assistant_response = self.assistant_agent.step(user_msg)
@@ -579,13 +578,7 @@ class RolePlaying:
             )
         assistant_msg = self._reduce_message_options(assistant_response.msgs)
 
-        # To prevent recording the same memory more than once (once in chat
-        # step and once in role play), and the model generates only one
-        # response when multi-response support is enabled.
-        if (
-            'n' in self.assistant_agent.model_backend.model_config_dict.keys()
-            and self.assistant_agent.model_backend.model_config_dict['n'] > 1
-        ):
+        if self._is_multi_response(self.assistant_agent):
             self.assistant_agent.record_message(assistant_msg)
 
         return (
@@ -639,13 +632,7 @@ class RolePlaying:
             )
         user_msg = self._reduce_message_options(user_response.msgs)
 
-        # To prevent recording the same memory more than once (once in chat
-        # step and once in role play), and the model generates only one
-        # response when multi-response support is enabled.
-        if (
-            'n' in self.user_agent.model_backend.model_config_dict.keys()
-            and self.user_agent.model_backend.model_config_dict['n'] > 1
-        ):
+        if self._is_multi_response(self.user_agent):
             self.user_agent.record_message(user_msg)
 
         assistant_response = await self.assistant_agent.astep(user_msg)
@@ -662,13 +649,7 @@ class RolePlaying:
             )
         assistant_msg = self._reduce_message_options(assistant_response.msgs)
 
-        # To prevent recording the same memory more than once (once in chat
-        # step and once in role play), and the model generates only one
-        # response when multi-response support is enabled.
-        if (
-            'n' in self.assistant_agent.model_backend.model_config_dict.keys()
-            and self.assistant_agent.model_backend.model_config_dict['n'] > 1
-        ):
+        if self._is_multi_response(self.assistant_agent):
             self.assistant_agent.record_message(assistant_msg)
 
         return (
@@ -730,3 +711,20 @@ class RolePlaying:
             new_instance.critic = self.critic.clone(with_memory)
 
         return new_instance
+
+    def _is_multi_response(self, agent: ChatAgent) -> bool:
+        r"""Checks if the given agent supports multi-response.
+
+        Args:
+            agent (ChatAgent): The agent to check for multi-response support.
+
+        Returns:
+            bool: True if the agent supports multi-response, False otherwise.
+        """
+        if (
+            'n' in agent.model_backend.model_config_dict.keys()
+            and agent.model_backend.model_config_dict['n'] is not None
+            and agent.model_backend.model_config_dict['n'] > 1
+        ):
+            return True
+        return False

camel/societies/workforce/workforce.py

@@ -111,27 +111,24 @@ class Workforce(BaseNode):
         children (Optional[List[BaseNode]], optional): List of child nodes
             under this node. Each child node can be a worker node or
             another workforce node. (default: :obj:`None`)
-        coordinator_agent_kwargs (Optional[Dict], optional): Keyword
-            arguments passed directly to the coordinator :obj:`ChatAgent`
-            constructor. The coordinator manages task assignment and failure
-            handling strategies. See :obj:`ChatAgent` documentation
-            for all available parameters.
-            (default: :obj:`None` - uses ModelPlatformType.DEFAULT,
-            ModelType.DEFAULT)
-        task_agent_kwargs (Optional[Dict], optional): Keyword arguments
-            passed directly to the task planning :obj:`ChatAgent` constructor.
-            The task agent handles task decomposition into subtasks and result
-            composition. See :obj:`ChatAgent` documentation for all
-            available parameters.
-            (default: :obj:`None` - uses ModelPlatformType.DEFAULT,
-            ModelType.DEFAULT)
-        new_worker_agent_kwargs (Optional[Dict], optional): Default keyword
-            arguments passed to :obj:`ChatAgent` constructor for workers
-            created dynamically at runtime when existing workers cannot handle
-            failed tasks. See :obj:`ChatAgent` documentation for all
-            available parameters.
-            (default: :obj:`None` - creates workers with SearchToolkit,
-            CodeExecutionToolkit, and ThinkingToolkit)
+        coordinator_agent (Optional[ChatAgent], optional): A custom coordinator
+            agent instance for task assignment and worker creation. If
+            provided, the workforce will create a new agent using this agent's
+            model configuration but with the required system message and
+            functionality.
+            If None, a default agent will be created using DEFAULT model
+            settings. (default: :obj:`None`)
+        task_agent (Optional[ChatAgent], optional): A custom task planning
+            agent instance for task decomposition and composition. If
+            provided, the workforce will create a new agent using this agent's
+            model configuration but with the required system message and tools
+            (TaskPlanningToolkit). If None, a default agent will be created
+            using DEFAULT model settings. (default: :obj:`None`)
+        new_worker_agent (Optional[ChatAgent], optional): A template agent for
+            workers created dynamically at runtime when existing workers cannot
+            handle failed tasks. If None, workers will be created with default
+            settings including SearchToolkit, CodeExecutionToolkit, and
+            ThinkingToolkit. (default: :obj:`None`)
         graceful_shutdown_timeout (float, optional): The timeout in seconds
             for graceful shutdown when a task fails 3 times. During this
             period, the workforce remains active for debugging.
@@ -147,40 +144,59 @@ class Workforce(BaseNode):
             (default: :obj:`False`)
 
     Example:
-        >>> # Configure with custom model and shared memory
         >>> import asyncio
+        >>> from camel.agents import ChatAgent
+        >>> from camel.models import ModelFactory
+        >>> from camel.types import ModelPlatformType, ModelType
+        >>> from camel.tasks import Task
+        >>>
+        >>> # Simple workforce with default agents
+        >>> workforce = Workforce("Research Team")
+        >>>
+        >>> # Workforce with custom model configuration
         >>> model = ModelFactory.create(
-        ...     ModelPlatformType.OPENAI, ModelType.GPT_4O
+        ...     ModelPlatformType.OPENAI, model_type=ModelType.GPT_4O
         ... )
+        >>> coordinator_agent = ChatAgent(model=model)
+        >>> task_agent = ChatAgent(model=model)
+        >>>
         >>> workforce = Workforce(
         ...     "Research Team",
-        ...     coordinator_agent_kwargs={"model": model, "token_limit": 4000},
-        ...     task_agent_kwargs={"model": model, "token_limit": 8000},
-        ...     share_memory=True  # Enable shared memory
+        ...     coordinator_agent=coordinator_agent,
+        ...     task_agent=task_agent,
         ... )
         >>>
         >>> # Process a task
         >>> async def main():
         ...     task = Task(content="Research AI trends", id="1")
-        ...     result = workforce.process_task(task)
+        ...     result = await workforce.process_task_async(task)
         ...     return result
-        >>> asyncio.run(main())
+        >>>
+        >>> result_task = asyncio.run(main())
+
+    Note:
+        When custom coordinator_agent or task_agent are provided, the workforce
+        will preserve the user's system message and append the required
+        workforce coordination or task planning instructions to it. This
+        ensures both the user's intent is preserved and proper workforce
+        functionality is maintained. All other agent configurations (model,
+        memory, tools, etc.) will also be preserved.
     """
 
     def __init__(
         self,
         description: str,
         children: Optional[List[BaseNode]] = None,
-        coordinator_agent_kwargs: Optional[Dict] = None,
-        task_agent_kwargs: Optional[Dict] = None,
-        new_worker_agent_kwargs: Optional[Dict] = None,
+        coordinator_agent: Optional[ChatAgent] = None,
+        task_agent: Optional[ChatAgent] = None,
+        new_worker_agent: Optional[ChatAgent] = None,  # TODO: use MCP Agent
         graceful_shutdown_timeout: float = 15.0,
         share_memory: bool = False,
     ) -> None:
         super().__init__(description)
         self._child_listening_tasks: Deque[asyncio.Task] = deque()
         self._children = children or []
-        self.new_worker_agent_kwargs = new_worker_agent_kwargs
+        self.new_worker_agent = new_worker_agent
         self.graceful_shutdown_timeout = graceful_shutdown_timeout
         self.share_memory = share_memory
         self.metrics_logger = WorkforceLogger(workforce_id=self.node_id)
@@ -214,58 +230,72 @@ class Workforce(BaseNode):
                     role=role_or_desc,
                 )
 
-        # Warning messages for default model usage
-        if coordinator_agent_kwargs is None:
-            logger.warning(
-                "No coordinator_agent_kwargs provided. Using default "
-                "ChatAgent settings (ModelPlatformType.DEFAULT, "
-                "ModelType.DEFAULT). To customize the coordinator agent "
-                "that assigns tasks and handles failures, pass a dictionary "
-                "with ChatAgent parameters, e.g.: {'model': your_model, "
-                "'tools': your_tools, 'token_limit': 8000}. See ChatAgent "
-                "documentation for all available options."
-            )
-        if task_agent_kwargs is None:
-            logger.warning(
-                "No task_agent_kwargs provided. Using default ChatAgent "
-                "settings (ModelPlatformType.DEFAULT, ModelType.DEFAULT). "
-                "To customize the task planning agent that "
-                "decomposes/composes tasks, pass a dictionary with "
-                "ChatAgent parameters, e.g.: {'model': your_model, "
-                "'token_limit': 16000}. See ChatAgent documentation for "
-                "all available options."
-            )
-        if new_worker_agent_kwargs is None:
-            logger.warning(
-                "No new_worker_agent_kwargs provided. Workers created at "
-                "runtime will use default ChatAgent settings with "
-                "SearchToolkit, CodeExecutionToolkit, and ThinkingToolkit. "
-                "To customize runtime worker creation, pass a dictionary "
-                "with ChatAgent parameters, e.g.: {'model': your_model, "
-                "'tools': your_tools}. See ChatAgent documentation for all "
-                "available options."
-            )
-
-        if self.share_memory:
-            logger.info(
-                "Shared memory enabled. All agents will share their complete "
-                "conversation history and function-calling trajectory for "
-                "better context continuity during task handoffs."
-            )
-
+        # Set up coordinator agent with default system message
         coord_agent_sys_msg = BaseMessage.make_assistant_message(
             role_name="Workforce Manager",
-            content="You are coordinating a group of workers. A worker can be "
-            "a group of agents or a single agent. Each worker is "
+            content="You are coordinating a group of workers. A worker "
+            "can be a group of agents or a single agent. Each worker is "
             "created to solve a specific kind of task. Your job "
             "includes assigning tasks to a existing worker, creating "
             "a new worker for a task, etc.",
         )
-        self.coordinator_agent = ChatAgent(
-            coord_agent_sys_msg,
-            **(coordinator_agent_kwargs or {}),
-        )
 
+        if coordinator_agent is None:
+            logger.warning(
+                "No coordinator_agent provided. Using default "
+                "ChatAgent settings (ModelPlatformType.DEFAULT, "
+                "ModelType.DEFAULT) with default system message."
+            )
+            self.coordinator_agent = ChatAgent(coord_agent_sys_msg)
+        else:
+            logger.info(
+                "Custom coordinator_agent provided. Preserving user's "
+                "system message and appending workforce coordination "
+                "instructions to ensure proper functionality."
+            )
+
+            if coordinator_agent.system_message is not None:
+                user_sys_msg_content = coordinator_agent.system_message.content
+                combined_content = (
+                    f"{user_sys_msg_content}\n\n"
+                    f"{coord_agent_sys_msg.content}"
+                )
+                combined_sys_msg = BaseMessage.make_assistant_message(
+                    role_name=coordinator_agent.system_message.role_name,
+                    content=combined_content,
+                )
+            else:
+                combined_sys_msg = coord_agent_sys_msg
+
+            # Create a new agent with the provided agent's configuration
+            # but with the combined system message
+            self.coordinator_agent = ChatAgent(
+                system_message=combined_sys_msg,
+                model=coordinator_agent.model_backend,
+                memory=coordinator_agent.memory,
+                message_window_size=getattr(
+                    coordinator_agent.memory, "window_size", None
+                ),
+                token_limit=getattr(
+                    coordinator_agent.memory.get_context_creator(),
+                    "token_limit",
+                    None,
+                ),
+                output_language=coordinator_agent.output_language,
+                tools=[
+                    tool.func
+                    for tool in coordinator_agent._internal_tools.values()
+                ],
+                external_tools=[
+                    schema
+                    for schema in coordinator_agent._external_tool_schemas.values()  # noqa: E501
+                ],
+                response_terminators=coordinator_agent.response_terminators,
+                max_iteration=coordinator_agent.max_iteration,
+                stop_event=coordinator_agent.stop_event,
+            )
+
+        # Set up task agent with default system message and required tools
         task_sys_msg = BaseMessage.make_assistant_message(
             role_name="Task Planner",
             content="You are going to compose and decompose tasks. Keep "
@@ -275,13 +305,83 @@ class Workforce(BaseNode):
             "of agents. This ensures efficient execution by minimizing "
             "context switching between agents.",
         )
-        _task_agent_kwargs = dict(task_agent_kwargs or {})
-        extra_tools = TaskPlanningToolkit().get_tools()
-        _task_agent_kwargs["tools"] = [
-            *_task_agent_kwargs.get("tools", []),
-            *extra_tools,
-        ]
-        self.task_agent = ChatAgent(task_sys_msg, **_task_agent_kwargs)
+        task_planning_tools = TaskPlanningToolkit().get_tools()
+
+        if task_agent is None:
+            logger.warning(
+                "No task_agent provided. Using default ChatAgent "
+                "settings (ModelPlatformType.DEFAULT, ModelType.DEFAULT) "
+                "with default system message and TaskPlanningToolkit."
+            )
+            self.task_agent = ChatAgent(
+                task_sys_msg,
+                tools=TaskPlanningToolkit().get_tools(),  # type: ignore[arg-type]
+            )
+        else:
+            logger.info(
+                "Custom task_agent provided. Preserving user's "
+                "system message and appending task planning "
+                "instructions to ensure proper functionality."
+            )
+
+            if task_agent.system_message is not None:
+                user_task_sys_msg_content = task_agent.system_message.content
+                combined_task_content = (
+                    f"{user_task_sys_msg_content}\n\n"
+                    f"{task_sys_msg.content}"
+                )
+                combined_task_sys_msg = BaseMessage.make_assistant_message(
+                    role_name=task_agent.system_message.role_name,
+                    content=combined_task_content,
+                )
+            else:
+                combined_task_sys_msg = task_sys_msg
+
+            # Since ChatAgent constructor uses a dictionary with
+            # function names as keys, we don't need to manually deduplicate.
+            combined_tools = [
+                tool.func for tool in task_agent._internal_tools.values()
+            ] + [tool.func for tool in task_planning_tools]
+
+            # Create a new agent with the provided agent's configuration
+            # but with the combined system message and tools
+            self.task_agent = ChatAgent(
+                system_message=combined_task_sys_msg,
+                model=task_agent.model_backend,
+                memory=task_agent.memory,
+                message_window_size=getattr(
+                    task_agent.memory, "window_size", None
+                ),
+                token_limit=getattr(
+                    task_agent.memory.get_context_creator(),
+                    "token_limit",
+                    None,
+                ),
+                output_language=task_agent.output_language,
+                tools=combined_tools,
+                external_tools=[
+                    schema
+                    for schema in task_agent._external_tool_schemas.values()
+                ],
+                response_terminators=task_agent.response_terminators,
+                max_iteration=task_agent.max_iteration,
+                stop_event=task_agent.stop_event,
+            )
+
+        if new_worker_agent is None:
+            logger.info(
+                "No new_worker_agent provided. Workers created at runtime "
+                "will use default ChatAgent settings with SearchToolkit, "
+                "CodeExecutionToolkit, and ThinkingToolkit. To customize "
+                "runtime worker creation, pass a ChatAgent instance."
+            )
+
+        if self.share_memory:
+            logger.info(
+                "Shared memory enabled. All agents will share their complete "
+                "conversation history and function-calling trajectory for "
+                "better context continuity during task handoffs."
+            )
 
     def __repr__(self):
         return (
@@ -1225,8 +1325,16 @@ class Workforce(BaseNode):
             )
             return TaskAssignResult(assignments=[])
 
-        result_dict = json.loads(response.msg.content, parse_int=str)
-        return TaskAssignResult(**result_dict)
+        try:
+            result_dict = json.loads(response.msg.content, parse_int=str)
+            return TaskAssignResult(**result_dict)
+        except json.JSONDecodeError as e:
+            logger.error(
+                f"JSON parsing error in task assignment: Invalid response "
+                f"format - {e}. Response content: "
+                f"{response.msg.content[:50]}..."
+            )
+            return TaskAssignResult(assignments=[])
 
     def _validate_assignments(
         self, assignments: List[TaskAssignment], valid_ids: Set[str]
@@ -1450,8 +1558,19 @@ class Workforce(BaseNode):
                 "with various tasks.",
             )
         else:
-            result_dict = json.loads(response.msg.content)
-            new_node_conf = WorkerConf(**result_dict)
+            try:
+                result_dict = json.loads(response.msg.content)
+                new_node_conf = WorkerConf(**result_dict)
+            except json.JSONDecodeError as e:
+                logger.error(
+                    f"JSON parsing error in worker creation: Invalid response "
+                    f"format - {e}. Response content: "
+                    f"{response.msg.content[:100]}..."
+                )
+                raise RuntimeError(
+                    f"Failed to create worker for task {task.id}: "
+                    f"Coordinator agent returned malformed JSON response. "
+                )
 
         new_agent = self._create_new_agent(
             new_node_conf.role,
@@ -1486,23 +1605,23 @@ class Workforce(BaseNode):
             content=sys_msg,
         )
 
-        if self.new_worker_agent_kwargs is not None:
-            return ChatAgent(worker_sys_msg, **self.new_worker_agent_kwargs)
-
-        # Default tools for a new agent
-        function_list = [
-            SearchToolkit().search_duckduckgo,
-            *CodeExecutionToolkit().get_tools(),
-            *ThinkingToolkit().get_tools(),
-        ]
+        if self.new_worker_agent is not None:
+            return self.new_worker_agent
+        else:
+            # Default tools for a new agent
+            function_list = [
+                SearchToolkit().search_duckduckgo,
+                *CodeExecutionToolkit().get_tools(),
+                *ThinkingToolkit().get_tools(),
+            ]
 
-        model = ModelFactory.create(
-            model_platform=ModelPlatformType.DEFAULT,
-            model_type=ModelType.DEFAULT,
-            model_config_dict={"temperature": 0},
-        )
+            model = ModelFactory.create(
+                model_platform=ModelPlatformType.DEFAULT,
+                model_type=ModelType.DEFAULT,
+                model_config_dict={"temperature": 0},
+            )
 
-        return ChatAgent(worker_sys_msg, model=model, tools=function_list)  # type: ignore[arg-type]
+            return ChatAgent(worker_sys_msg, model=model, tools=function_list)  # type: ignore[arg-type]
 
     async def _get_returned_task(self) -> Task:
         r"""Get the task that's published by this node and just get returned
@@ -1988,28 +2107,17 @@ class Workforce(BaseNode):
         """
 
         # Create a new instance with the same configuration
-        # Extract the original kwargs from the agents to properly clone them
-        coordinator_kwargs = (
-            getattr(self.coordinator_agent, 'init_kwargs', {}) or {}
-        )
-        task_kwargs = getattr(self.task_agent, 'init_kwargs', {}) or {}
-
         new_instance = Workforce(
             description=self.description,
-            coordinator_agent_kwargs=coordinator_kwargs.copy(),
-            task_agent_kwargs=task_kwargs.copy(),
-            new_worker_agent_kwargs=self.new_worker_agent_kwargs.copy()
-            if self.new_worker_agent_kwargs
+            coordinator_agent=self.coordinator_agent.clone(with_memory),
+            task_agent=self.task_agent.clone(with_memory),
+            new_worker_agent=self.new_worker_agent.clone(with_memory)
+            if self.new_worker_agent
             else None,
             graceful_shutdown_timeout=self.graceful_shutdown_timeout,
             share_memory=self.share_memory,
         )
 
-        new_instance.task_agent = self.task_agent.clone(with_memory)
-        new_instance.coordinator_agent = self.coordinator_agent.clone(
-            with_memory
-        )
-
         for child in self._children:
             if isinstance(child, SingleAgentWorker):
                 cloned_worker = child.worker.clone(with_memory)

camel/societies/workforce/workforce_logger.py

@@ -499,54 +499,68 @@ class WorkforceLogger:
 
         tasks_handled_by_worker: Dict[str, int] = {}
 
+        # Helper function to check if a task is the main task (has no parent)
+        def is_main_task(task_id: str) -> bool:
+            return (
+                task_id in self._task_hierarchy
+                and self._task_hierarchy[task_id].get('parent') is None
+            )
+
         for entry in self.log_entries:
             event_type = entry['event_type']
             timestamp = datetime.fromisoformat(entry['timestamp'])
+            task_id = entry.get('task_id', '')
+
             if first_timestamp is None or timestamp < first_timestamp:
                 first_timestamp = timestamp
             if last_timestamp is None or timestamp > last_timestamp:
                 last_timestamp = timestamp
 
             if event_type == 'task_created':
-                kpis['total_tasks_created'] += 1
-                task_creation_timestamps[entry['task_id']] = timestamp
+                # Exclude main task from total count
+                if not is_main_task(task_id):
+                    kpis['total_tasks_created'] += 1
+                task_creation_timestamps[task_id] = timestamp
             elif event_type == 'task_assigned':
-                task_assignment_timestamps[entry['task_id']] = timestamp
+                task_assignment_timestamps[task_id] = timestamp
                 # Queue time tracking has been removed
 
             elif event_type == 'task_started':
                 # Store start time for processing time calculation
-                task_start_times[entry['task_id']] = timestamp.timestamp()
+                task_start_times[task_id] = timestamp.timestamp()
 
             elif event_type == 'task_completed':
-                kpis['total_tasks_completed'] += 1
-                # Count tasks handled by worker
-                if 'worker_id' in entry and entry['worker_id'] is not None:
-                    worker_id = entry['worker_id']
-                    tasks_handled_by_worker[worker_id] = (
-                        tasks_handled_by_worker.get(worker_id, 0) + 1
-                    )
+                # Exclude main task from total count
+                if not is_main_task(task_id):
+                    kpis['total_tasks_completed'] += 1
+                    # Count tasks handled by worker (only for non-main tasks)
+                    if 'worker_id' in entry and entry['worker_id'] is not None:
+                        worker_id = entry['worker_id']
+                        tasks_handled_by_worker[worker_id] = (
+                            tasks_handled_by_worker.get(worker_id, 0) + 1
+                        )
 
-                if entry['task_id'] in task_assignment_timestamps:
+                if task_id in task_assignment_timestamps:
                     completion_time = (
-                        timestamp
-                        - task_assignment_timestamps[entry['task_id']]
+                        timestamp - task_assignment_timestamps[task_id]
                     ).total_seconds()
                     # Store completion time in task hierarchy instead of KPIs
                     # array
-                    if entry['task_id'] in self._task_hierarchy:
-                        self._task_hierarchy[entry['task_id']][
+                    if task_id in self._task_hierarchy:
+                        self._task_hierarchy[task_id][
                             'completion_time_seconds'
                         ] = completion_time
 
             elif event_type == 'task_failed':
-                kpis['total_tasks_failed'] += 1
-                # Count tasks handled by worker (also for failed tasks)
-                if 'worker_id' in entry and entry['worker_id'] is not None:
-                    worker_id = entry['worker_id']
-                    tasks_handled_by_worker[worker_id] = (
-                        tasks_handled_by_worker.get(worker_id, 0) + 1
-                    )
+                # Exclude main task from total count
+                if not is_main_task(task_id):
+                    kpis['total_tasks_failed'] += 1
+                    # Count tasks handled by worker (only for non-main tasks)
+                    if 'worker_id' in entry and entry['worker_id'] is not None:
+                        worker_id = entry['worker_id']
+                        tasks_handled_by_worker[worker_id] = (
+                            tasks_handled_by_worker.get(worker_id, 0) + 1
+                        )
                 error_type = entry['error_type']
                 kpis['error_types_count'][error_type] = (
                     kpis['error_types_count'].get(error_type, 0) + 1

camel/storages/__init__.py

@@ -30,6 +30,7 @@ from .vectordb_storages.chroma import ChromaStorage
 from .vectordb_storages.faiss import FaissStorage
 from .vectordb_storages.milvus import MilvusStorage
 from .vectordb_storages.oceanbase import OceanBaseStorage
+from .vectordb_storages.pgvector import PgVectorStorage
 from .vectordb_storages.qdrant import QdrantStorage
 from .vectordb_storages.tidb import TiDBStorage
 from .vectordb_storages.weaviate import WeaviateStorage
@@ -53,5 +54,6 @@ __all__ = [
     'Mem0Storage',
     'OceanBaseStorage',
     'WeaviateStorage',
+    'PgVectorStorage',
     'ChromaStorage',
 ]

camel/storages/vectordb_storages/__init__.py

@@ -23,6 +23,7 @@ from .chroma import ChromaStorage
 from .faiss import FaissStorage
 from .milvus import MilvusStorage
 from .oceanbase import OceanBaseStorage
+from .pgvector import PgVectorStorage
 from .qdrant import QdrantStorage
 from .tidb import TiDBStorage
 from .weaviate import WeaviateStorage
@@ -40,4 +41,5 @@ __all__ = [
     'WeaviateStorage',
     'VectorRecord',
     'VectorDBStatus',
+    'PgVectorStorage',
 ]

camel/storages/vectordb_storages/pgvector.py

@@ -0,0 +1,349 @@
+# ========= 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. =========
+
+import json
+from typing import Any, Dict, List, Optional
+
+from camel.logger import get_logger
+from camel.storages.vectordb_storages import (
+    BaseVectorStorage,
+    VectorDBQuery,
+    VectorDBQueryResult,
+    VectorDBStatus,
+    VectorRecord,
+)
+from camel.types import VectorDistance
+from camel.utils import dependencies_required
+
+logger = get_logger(__name__)
+
+
+class PgVectorStorage(BaseVectorStorage):
+    r"""PgVectorStorage is an implementation of BaseVectorStorage for
+    PostgreSQL with pgvector extension.
+
+    This class provides methods to add, delete, query, and manage vector
+    records in a PostgreSQL database using the pgvector extension.
+    It supports different distance metrics for similarity search.
+
+    Args:
+        vector_dim (int): The dimension of the vectors to be stored.
+        conn_info (Dict[str, Any]): Connection information for
+            psycopg2.connect.
+        table_name (str, optional): Name of the table to store vectors.
+            (default: :obj:`None`)
+        distance (VectorDistance, optional): Distance metric for vector
+            comparison. (default: :obj:`VectorDistance.COSINE`)
+    """
+
+    @dependencies_required('psycopg', 'pgvector')
+    def __init__(
+        self,
+        vector_dim: int,
+        conn_info: Dict[str, Any],
+        table_name: Optional[str] = None,
+        distance: VectorDistance = VectorDistance.COSINE,
+        **kwargs: Any,
+    ) -> None:
+        r"""Initialize PgVectorStorage.
+
+        Args:
+            vector_dim (int): The dimension of the vectors.
+            conn_info (Dict[str, Any]): Connection info for psycopg2.connect.
+            table_name (str, optional): Table name. (default: :obj:`None`)
+            distance (VectorDistance, optional): Distance metric.
+                (default: :obj:`VectorDistance.COSINE`)
+        """
+        import psycopg
+        from pgvector.psycopg import register_vector
+
+        if vector_dim <= 0:
+            raise ValueError("vector_dim must be positive")
+
+        self.vector_dim = vector_dim
+        self.conn_info = conn_info
+        self.table_name = table_name or 'vectors'
+        self.distance = distance
+
+        try:
+            self._conn = psycopg.connect(**conn_info)
+            register_vector(self._conn)
+            self._ensure_table()
+            self._ensure_index()
+        except Exception as e:
+            logger.error(f"Failed to initialize PgVectorStorage: {e}")
+            raise
+
+    def _ensure_table(self) -> None:
+        r"""Ensure the vector table exists in the database.
+        Creates the table if it does not exist.
+        """
+        try:
+            from psycopg.sql import SQL, Identifier, Literal
+
+            with self._conn.cursor() as cur:
+                query = SQL("""
+                    CREATE TABLE IF NOT EXISTS {table} (
+                        id VARCHAR PRIMARY KEY,
+                        vector vector({dim}),
+                        payload JSONB
+                    )
+                """).format(
+                    table=Identifier(self.table_name),
+                    dim=Literal(self.vector_dim),
+                )
+                cur.execute(query)
+                self._conn.commit()
+        except Exception as e:
+            logger.error(f"Failed to create table {self.table_name}: {e}")
+            raise
+
+    def _ensure_index(self) -> None:
+        r"""Ensure vector similarity search index exists for better
+        performance.
+        """
+        try:
+            from psycopg.sql import SQL, Identifier
+
+            with self._conn.cursor() as cur:
+                index_name = f"{self.table_name}_vector_idx"
+                query = SQL("""
+                    CREATE INDEX IF NOT EXISTS {index_name} 
+                    ON {table} 
+                    USING hnsw (vector vector_cosine_ops)
+                """).format(
+                    index_name=Identifier(index_name),
+                    table=Identifier(self.table_name),
+                )
+                cur.execute(query)
+                self._conn.commit()
+        except Exception as e:
+            logger.warning(f"Failed to create vector index: {e}")
+
+    def add(self, records: List[VectorRecord], **kwargs: Any) -> None:
+        r"""Add or update vector records in the database.
+
+        Args:
+            records (List[VectorRecord]): List of vector records to
+                add or update.
+        """
+        if not records:
+            return
+
+        try:
+            with self._conn.cursor() as cur:
+                # Use batch insert for better performance
+                batch_data = []
+                for rec in records:
+                    if len(rec.vector) != self.vector_dim:
+                        raise ValueError(
+                            f"Vector dimension mismatch: expected "
+                            f"{self.vector_dim}, got {len(rec.vector)}"
+                        )
+
+                    batch_data.append(
+                        (
+                            rec.id,
+                            rec.vector,
+                            json.dumps(rec.payload)
+                            if rec.payload is not None
+                            else None,
+                        )
+                    )
+
+                # Use executemany for efficient batch insert
+                from psycopg.sql import SQL, Identifier
+
+                query = SQL("""
+                    INSERT INTO {table} (id, vector, payload)
+                    VALUES (%s, %s, %s)
+                    ON CONFLICT (id) DO UPDATE SET 
+                    vector=EXCLUDED.vector, 
+                    payload=EXCLUDED.payload
+                """).format(table=Identifier(self.table_name))
+
+                cur.executemany(query, batch_data)
+                self._conn.commit()
+        except Exception as e:
+            self._conn.rollback()
+            logger.error(f"Failed to add records: {e}")
+            raise
+
+    def delete(self, ids: List[str], **kwargs: Any) -> None:
+        r"""Delete vector records from the database by their IDs.
+
+        Args:
+            ids (List[str]): List of record IDs to delete.
+        """
+        from psycopg.sql import SQL, Identifier
+
+        if not ids:
+            return
+
+        try:
+            with self._conn.cursor() as cur:
+                query = SQL("DELETE FROM {table} WHERE id = ANY(%s)").format(
+                    table=Identifier(self.table_name)
+                )
+                cur.execute(query, (ids,))
+                self._conn.commit()
+        except Exception as e:
+            self._conn.rollback()
+            logger.error(f"Failed to delete records: {e}")
+            raise
+
+    def query(
+        self, query: VectorDBQuery, **kwargs: Any
+    ) -> List[VectorDBQueryResult]:
+        r"""Query the database for the most similar vectors to the given
+        query vector.
+
+        Args:
+            query (VectorDBQuery): Query object containing the query
+                vector and top_k.
+            **kwargs (Any): Additional keyword arguments for the query.
+
+        Returns:
+            List[VectorDBQueryResult]: List of query results sorted by
+                similarity.
+        """
+        if len(query.query_vector) != self.vector_dim:
+            raise ValueError(
+                f"Query vector dimension mismatch: "
+                f"expected {self.vector_dim}, got {len(query.query_vector)}"
+            )
+
+        try:
+            with self._conn.cursor() as cur:
+                # Fix distance metric mapping
+                metric_info = {
+                    VectorDistance.COSINE: ('<=>', 'ASC'),  # Cosine distance
+                    VectorDistance.EUCLIDEAN: (
+                        '<->',
+                        'ASC',
+                    ),  # Euclidean distance
+                    VectorDistance.DOT: (
+                        '<#>',
+                        'DESC',
+                    ),  # Negative dot product (higher is better)
+                }
+
+                if self.distance not in metric_info:
+                    raise ValueError(
+                        f"Unsupported distance metric: {self.distance}"
+                    )
+
+                metric, order = metric_info[self.distance]
+
+                from psycopg.sql import SQL, Identifier, Literal
+
+                query_sql = SQL("""
+                    SELECT id, vector, payload, (vector {} %s::vector) 
+                    AS similarity
+                    FROM {}
+                    ORDER BY similarity {}
+                    LIMIT %s
+                """).format(
+                    Literal(metric),
+                    Identifier(self.table_name),
+                    Literal(order),
+                )
+
+                cur.execute(query_sql, (query.query_vector, query.top_k))
+                results = []
+                for row in cur.fetchall():
+                    id, vector, payload, similarity = row
+                    results.append(
+                        VectorDBQueryResult.create(
+                            similarity=float(similarity),
+                            vector=list(vector),
+                            id=id,
+                            payload=payload,
+                        )
+                    )
+                return results
+        except Exception as e:
+            logger.error(f"Failed to query vectors: {e}")
+            raise
+
+    def status(self, **kwargs: Any) -> VectorDBStatus:
+        r"""Get the status of the vector database, including vector
+        dimension and count.
+
+        Args:
+            **kwargs (Any): Additional keyword arguments for the query.
+
+        Returns:
+            VectorDBStatus: Status object with vector dimension and count.
+        """
+        try:
+            with self._conn.cursor() as cur:
+                from psycopg.sql import SQL, Identifier
+
+                query = SQL('SELECT COUNT(*) FROM {}').format(
+                    Identifier(self.table_name)
+                )
+                cur.execute(query)
+                result = cur.fetchone()
+                count = result[0] if result else 0
+                return VectorDBStatus(
+                    vector_dim=self.vector_dim, vector_count=count
+                )
+        except Exception as e:
+            logger.error(f"Failed to get status: {e}")
+            raise
+
+    def clear(self) -> None:
+        r"""Remove all vectors from the storage by truncating the table."""
+        try:
+            with self._conn.cursor() as cur:
+                from psycopg.sql import SQL, Identifier
+
+                query = SQL("TRUNCATE TABLE {table}").format(
+                    table=Identifier(self.table_name)
+                )
+                cur.execute(query)
+                self._conn.commit()
+        except Exception as e:
+            self._conn.rollback()
+            logger.error(f"Failed to clear table: {e}")
+            raise
+
+    def load(self) -> None:
+        r"""Load the collection hosted on cloud service (no-op for pgvector).
+        This method is provided for interface compatibility.
+        """
+        # For PostgreSQL local/managed instances, no loading is required
+        pass
+
+    def close(self) -> None:
+        r"""Close the database connection."""
+        if hasattr(self, '_conn') and self._conn:
+            try:
+                self._conn.close()
+            except Exception as e:
+                logger.warning(f"Error closing connection: {e}")
+
+    def __del__(self) -> None:
+        r"""Ensure connection is closed when object is destroyed."""
+        self.close()
+
+    @property
+    def client(self) -> Any:
+        r"""Provides access to the underlying vector database client.
+
+        Returns:
+            Any: The underlying psycopg connection object.
+        """
+        return self._conn

camel/toolkits/file_write_toolkit.py

@@ -176,26 +176,40 @@ class FileWriteToolkit(BaseToolkit):
 
             doc = Document(documentclass="article")
             doc.packages.append(Command('usepackage', 'amsmath'))
-
             with doc.create(Section('Generated Content')):
                 for line in content.split('\n'):
-                    # Remove leading whitespace
                     stripped_line = line.strip()
-                    # Check if the line is intended as a standalone math
-                    # expression
+
+                    # Skip empty lines
+                    if not stripped_line:
+                        continue
+
+                    # Convert Markdown-like headers
+                    if stripped_line.startswith('## '):
+                        header = stripped_line[3:]
+                        doc.append(NoEscape(r'\subsection*{%s}' % header))
+                        continue
+                    elif stripped_line.startswith('# '):
+                        header = stripped_line[2:]
+                        doc.append(NoEscape(r'\section*{%s}' % header))
+                        continue
+                    elif stripped_line.strip() == '---':
+                        doc.append(NoEscape(r'\hrule'))
+                        continue
+
+                    # Detect standalone math expressions like $...$
                     if (
                         stripped_line.startswith('$')
                         and stripped_line.endswith('$')
                         and len(stripped_line) > 1
                     ):
-                        # Extract content between the '$' delimiters
                         math_data = stripped_line[1:-1]
                         doc.append(Math(data=math_data))
                     else:
-                        doc.append(NoEscape(line))
+                        doc.append(NoEscape(stripped_line))
                     doc.append(NoEscape(r'\par'))
 
-            doc.generate_pdf(str(file_path), clean_tex=False)
+                doc.generate_pdf(str(file_path), clean_tex=True)
 
             logger.info(f"Wrote PDF (with LaTeX) to {file_path}")
         else:

camel/toolkits/terminal_toolkit.py

@@ -187,7 +187,8 @@ class TerminalToolkit(BaseToolkit):
             logger.error(f"Failed to create environment: {e}")
 
     def _create_terminal(self):
-        r"""Create a terminal GUI."""
+        r"""Create a terminal GUI. If GUI creation fails, fallback
+        to file output."""
 
         try:
             import tkinter as tk
@@ -239,7 +240,12 @@ class TerminalToolkit(BaseToolkit):
             self.root.mainloop()
 
         except Exception as e:
-            logger.error(f"Failed to create terminal: {e}")
+            logger.warning(
+                f"Failed to create GUI terminal: {e}, "
+                f"falling back to file output mode"
+            )
+            # Fallback to file output mode when GUI creation fails
+            self._setup_file_output()
             self.terminal_ready.set()
 
     def _update_terminal_output(self, output: str):
@@ -249,8 +255,9 @@ class TerminalToolkit(BaseToolkit):
             output (str): The output to be sent to the agent
         """
         try:
-            # If it is macOS , only write to file
-            if self.is_macos:
+            # If it is macOS or if we have a log_file (fallback mode),
+            # write to file
+            if self.is_macos or hasattr(self, 'log_file'):
                 if hasattr(self, 'log_file'):
                     with open(self.log_file, "a") as f:
                         f.write(output)

camel/types/enums.py

@@ -209,6 +209,7 @@ class ModelType(UnifiedModelType, Enum):
     MISTRAL_PIXTRAL_12B = "pixtral-12b-2409"
     MISTRAL_MEDIUM_3 = "mistral-medium-latest"
     MAGISTRAL_MEDIUM = "magistral-medium-2506"
+    MISTRAL_SMALL_3_2 = "mistral-small-2506"
 
     # Reka models
     REKA_CORE = "reka-core"
@@ -646,6 +647,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.MISTRAL_3B,
             ModelType.MISTRAL_MEDIUM_3,
             ModelType.MAGISTRAL_MEDIUM,
+            ModelType.MISTRAL_SMALL_3_2,
         }
 
     @property
@@ -1166,6 +1168,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.MISTRAL_PIXTRAL_12B,
             ModelType.MISTRAL_8B,
             ModelType.MISTRAL_3B,
+            ModelType.MISTRAL_SMALL_3_2,
             ModelType.QWEN_2_5_CODER_32B,
             ModelType.QWEN_2_5_VL_72B,
             ModelType.QWEN_2_5_72B,

{camel_ai-0.2.69a7.dist-info → camel_ai-0.2.70.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.69a7
+Version: 0.2.70
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -87,10 +87,12 @@ Requires-Dist: openapi-spec-validator<0.8,>=0.7.1; extra == 'all'
 Requires-Dist: openpyxl>=3.1.5; extra == 'all'
 Requires-Dist: pandas<2,>=1.5.3; extra == 'all'
 Requires-Dist: pandasai<3,>=2.3.0; extra == 'all'
+Requires-Dist: pgvector<0.3,>=0.2.4; extra == 'all'
 Requires-Dist: playwright>=1.50.0; extra == 'all'
 Requires-Dist: prance<24,>=23.6.21.0; extra == 'all'
 Requires-Dist: praw<8,>=7.7.1; extra == 'all'
 Requires-Dist: pre-commit<4,>=3; extra == 'all'
+Requires-Dist: psycopg[binary]<4,>=3.1.18; extra == 'all'
 Requires-Dist: pyautogui<0.10,>=0.9.54; extra == 'all'
 Requires-Dist: pydub<0.26,>=0.25.1; extra == 'all'
 Requires-Dist: pygithub<3,>=2.6.0; extra == 'all'
@@ -319,6 +321,8 @@ Requires-Dist: google-cloud-storage<3,>=2.18.0; extra == 'storage'
 Requires-Dist: mem0ai>=0.1.73; extra == 'storage'
 Requires-Dist: nebula3-python==3.8.2; extra == 'storage'
 Requires-Dist: neo4j<6,>=5.18.0; extra == 'storage'
+Requires-Dist: pgvector<0.3,>=0.2.4; extra == 'storage'
+Requires-Dist: psycopg[binary]<4,>=3.1.18; extra == 'storage'
 Requires-Dist: pymilvus<3,>=2.4.0; extra == 'storage'
 Requires-Dist: pyobvector>=0.1.18; extra == 'storage'
 Requires-Dist: pytidb-experimental==0.0.1.dev4; extra == 'storage'

{camel_ai-0.2.69a7.dist-info → camel_ai-0.2.70.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=vkLh3hF0BR8jlE-z2-sb5h5QW_tmF_f7ZqfuVAwBlWo,901
+camel/__init__.py,sha256=rtQ7MDzPTxNXpydxnv9IwyW7crRkyL7PBwDGcQg017U,899
 camel/generators.py,sha256=JRqj9_m1PF4qT6UtybzTQ-KBT9MJQt18OAAYvQ_fr2o,13844
 camel/human.py,sha256=Xg8x1cS5KK4bQ1SDByiHZnzsRpvRP-KZViNvmu38xo4,5475
 camel/logger.py,sha256=rZVeOVYuQ9RYJ5Tqyv0usqy0g4zaVEq4qSfZ9nd2640,5755
@@ -268,7 +268,7 @@ camel/schemas/openai_converter.py,sha256=SEnYsYcboZgVmjcC1YP5xke3c0MYPESPRmYQWsD
 camel/schemas/outlines_converter.py,sha256=OYKPR1fNyrYs9eh5RiXEAccMbnRc9WTwSVJYbh9HkKE,8738
 camel/societies/__init__.py,sha256=NOHjtlsY-gV9UCF2xXgcbG-xXyuigmbwbpLpNsDgEJ4,826
 camel/societies/babyagi_playing.py,sha256=KbTdpHfZ2V8AripVck0bNTOyF-RSaMPCRARz3DvzWfQ,11855
-camel/societies/role_playing.py,sha256=1TsQbGYmN91BeQ0DGM5PpSJ9TMbn1F3maJNuv4fQ5zI,31749
+camel/societies/role_playing.py,sha256=0XScr3WfxX1QOC71RhBLmrcS5y2c7DMQB_mAFOHU34M,31421
 camel/societies/workforce/__init__.py,sha256=bkTI-PE-MSK9AQ2V2gR6cR2WY-R7Jqy_NmXRtAoqo8o,920
 camel/societies/workforce/base.py,sha256=z2DmbTP5LL5-aCAAqglznQqCLfPmnyM5zD3w6jjtsb8,2175
 camel/societies/workforce/prompts.py,sha256=_l7OUkzH5p7KOd8HMZle9zB9W3jKza_Yb_6elFKiZ2s,11813
@@ -277,9 +277,9 @@ camel/societies/workforce/single_agent_worker.py,sha256=ZDVq5doJUoUY0Uuvhkucf4U-
 camel/societies/workforce/task_channel.py,sha256=uqQQI67Tr4awbR4bjZXdx8_4gL6-ON5IjQk_H_ryqT4,7431
 camel/societies/workforce/utils.py,sha256=Gjlz7pLo4r1b6iNHtlIMxeEuat4d6tEEQMI40JAU3kY,6190
 camel/societies/workforce/worker.py,sha256=36tkOyz4G2wfBdrFjt9NBPXsx4UbE6uL5on8sP2aoqk,6414
-camel/societies/workforce/workforce.py,sha256=egpMtgiwy3Fs0cW3zskjArTF-EcQTDRYba2DRhGSkds,95862
-camel/societies/workforce/workforce_logger.py,sha256=2xGMMYQPphC5WlPbgWWp9SEY2hGpP-GkhgsNC19irns,24237
-camel/storages/__init__.py,sha256=M2sJ0f7fav-KZNI0yz_rYAYZJ8I1VoWo5ETHykR_rrA,2062
+camel/societies/workforce/workforce.py,sha256=Nm7TML3I_rZVo22lLxt27fpBUopfFkG1MacVKCPJRIY,100497
+camel/societies/workforce/workforce_logger.py,sha256=7xOnmsqeHNoNiwqhFyh3SUtfOHCslCoX6aB2MMCnb0M,24865
+camel/storages/__init__.py,sha256=RwpEyvxpMbJzVDZJJygeBg4AzyYMkTjjkfB53hTuqGo,2141
 camel/storages/graph_storages/__init__.py,sha256=G29BNn651C0WTOpjCl4QnVM-4B9tcNh8DdmsCiONH8Y,948
 camel/storages/graph_storages/base.py,sha256=uSe9jWuLudfm5jtfo6E-L_kNzITwK1_Ef-6L4HWw-JM,2852
 camel/storages/graph_storages/graph_element.py,sha256=X_2orbQOMaQd00xxzAoJLfEcrVNE1mgCqMJv0orMAKA,2733
@@ -296,12 +296,13 @@ camel/storages/object_storages/amazon_s3.py,sha256=9Yvyyyb1LGHxr8REEza7oGopbVtLE
 camel/storages/object_storages/azure_blob.py,sha256=66dHcvjE2ZNdb339oBU6LbFiKzPYrnlb4tQ_3m2Yazc,5992
 camel/storages/object_storages/base.py,sha256=pImWylYJm7Wt8q87lBE1Cxk26IJ9sRtXq_OJmV6bJlg,3796
 camel/storages/object_storages/google_cloud.py,sha256=59AvGar_GDoGYHhzUi5KBtInv2KaUVnw8SalsL43410,5332
-camel/storages/vectordb_storages/__init__.py,sha256=vZ8SXDRMULAYd1YVLxyUUbX2X-8Z6ZJVkkyEtL9BScU,1351
+camel/storages/vectordb_storages/__init__.py,sha256=ZxN9EWkhh4W9LGfpwmnQkpiaY1dEfvVERd6QZ-jN4Bs,1412
 camel/storages/vectordb_storages/base.py,sha256=EP_WbEtI3SJPHro9rjNkIq9UDUP1AAHmxZgeya94Lgk,6738
 camel/storages/vectordb_storages/chroma.py,sha256=wXuLUYsgkC2VvdyLrlL5VqEDVzJDBUo7OdimK8hBLmg,27553
 camel/storages/vectordb_storages/faiss.py,sha256=MHE3db9kJmVuu0aScXsSo8p60TCtc2Ot0rO77zcPgt8,26760
 camel/storages/vectordb_storages/milvus.py,sha256=ChQyEuaXCWCKxytLN2z4QrkEthx2xE6bQPO6KCS9RgQ,13535
 camel/storages/vectordb_storages/oceanbase.py,sha256=eNBelw4D6r3OWlhHzGJ8Xw-ej9nU1uTZ6CYoXdbxDkI,17054
+camel/storages/vectordb_storages/pgvector.py,sha256=p-5RGCVT46zP-Yop85thWi2m0ZnHILSJFpu2A-7qWnk,12438
 camel/storages/vectordb_storages/qdrant.py,sha256=a_cT0buSCHQ2CPZy852-mdvMDwy5zodCvAKMaa4zIvg,18017
 camel/storages/vectordb_storages/tidb.py,sha256=w83bxgKgso43MtHqlpf2EMSpn1_Nz6ZZtY4fPw_-vgs,11192
 camel/storages/vectordb_storages/weaviate.py,sha256=wDUE4KvfmOl3DqHFU4uF0VKbHu-q9vKhZDe8FZ6QXsk,27888
@@ -329,7 +330,7 @@ camel/toolkits/dappier_toolkit.py,sha256=OEHOYXX_oXhgbVtWYAy13nO9uXf9i5qEXSwY4Pe
 camel/toolkits/data_commons_toolkit.py,sha256=aHZUSL1ACpnYGaf1rE2csVKTmXTmN8lMGRUBYhZ_YEk,14168
 camel/toolkits/edgeone_pages_mcp_toolkit.py,sha256=1TFpAGHUNLggFQeN1OEw7P5laijwnlrCkfxBtgxFuUY,2331
 camel/toolkits/excel_toolkit.py,sha256=9Uk5GLWl719c4W-NcGPJTNMtodAbEE5gUgLsFkIInbk,32564
-camel/toolkits/file_write_toolkit.py,sha256=i1CivjvqTpHakYK_EynNvNikjZZYsusxkjT2v-f9EYc,16473
+camel/toolkits/file_write_toolkit.py,sha256=8G7swo_9EXpbt5IO-hCy-Wf5BPd70ewfpCHqErPsCXU,17072
 camel/toolkits/function_tool.py,sha256=xCDzjxTRCVj_kmbnMFBuwK-3NuzM4JNe_kv9HLtjnIA,33644
 camel/toolkits/github_toolkit.py,sha256=iUyRrjWGAW_iljZVfNyfkm1Vi55wJxK6PsDAQs9pOag,13099
 camel/toolkits/google_calendar_toolkit.py,sha256=E-sdgdbtNBs_CXbhht9t1dsVr4DsTr5NguHkx4fvSmc,15410
@@ -367,7 +368,7 @@ camel/toolkits/slack_toolkit.py,sha256=Nb3w-TbUmnUWEvHE9Hbf_wkpSepm_zKQj7m19UyoF
 camel/toolkits/stripe_toolkit.py,sha256=07swo5znGTnorafC1uYLKB4NRcJIOPOx19J7tkpLYWk,10102
 camel/toolkits/sympy_toolkit.py,sha256=BAQnI8EFJydNUpKQWXBdleQ1Cm-srDBhFlqp9V9pbPQ,33757
 camel/toolkits/task_planning_toolkit.py,sha256=Ttw9fHae4omGC1SA-6uaeXVHJ1YkwiVloz_hO-fm1gw,4855
-camel/toolkits/terminal_toolkit.py,sha256=gupuTvNkwnFzcFwDB_irSJ9-dXRr8yEAsYq5ChEkkHg,37230
+camel/toolkits/terminal_toolkit.py,sha256=15pEz281g_6sJq5xGPdFFonjjHEDPf-NGJtfM-csOu0,37559
 camel/toolkits/thinking_toolkit.py,sha256=nZYLvKWIx2BM1DYu69I9B5EISAG7aYcLYXKv9663BVk,8000
 camel/toolkits/twitter_toolkit.py,sha256=Px4N8aUxUzy01LhGSWkdrC2JgwKkrY3cvxgMeJ2XYfU,15939
 camel/toolkits/video_analysis_toolkit.py,sha256=Wh08MAVvs3PtgXN88Sk0TXYaGfVmQAol8FPCXMPPpIM,23375
@@ -409,7 +410,7 @@ camel/toolkits/open_api_specs/web_scraper/openapi.yaml,sha256=u_WalQ01e8W1D27VnZ
 camel/toolkits/open_api_specs/web_scraper/paths/__init__.py,sha256=OKCZrQCDwaWtXIN_2rA9FSqEvgpQRieRoHh7Ek6N16A,702
 camel/toolkits/open_api_specs/web_scraper/paths/scraper.py,sha256=aWy1_ppV4NVVEZfnbN3tu9XA9yAPAC9bRStJ5JuXMRU,1117
 camel/types/__init__.py,sha256=pFTg3CWGSCfwFdoxPDTf4dKV8DdJS1x-bBPuEOmtdf0,2549
-camel/types/enums.py,sha256=PEDoxtXq6SLbAYBFw4gr2H4XC7qgB-6lhPENMjlfb18,62887
+camel/types/enums.py,sha256=FsUh5p4xo_c-h1Z5xzE7HeSue-pYUR7s4zzkYEDRBwI,63014
 camel/types/mcp_registries.py,sha256=dl4LgYtSaUhsqAKpz28k_SA9La11qxqBvDLaEuyzrFE,4971
 camel/types/openai_types.py,sha256=8ZFzLe-zGmKNPfuVZFzxlxAX98lGf18gtrPhOgMmzus,2104
 camel/types/unified_model_type.py,sha256=ZweHiS4MQ1QbDEX3a3oUc-pvgueYP27Zt0SlAPcYg_4,5623
@@ -436,7 +437,7 @@ camel/verifiers/math_verifier.py,sha256=tA1D4S0sm8nsWISevxSN0hvSVtIUpqmJhzqfbuMo
 camel/verifiers/models.py,sha256=GdxYPr7UxNrR1577yW4kyroRcLGfd-H1GXgv8potDWU,2471
 camel/verifiers/physics_verifier.py,sha256=c1grrRddcrVN7szkxhv2QirwY9viIRSITWeWFF5HmLs,30187
 camel/verifiers/python_verifier.py,sha256=ogTz77wODfEcDN4tMVtiSkRQyoiZbHPY2fKybn59lHw,20558
-camel_ai-0.2.69a7.dist-info/METADATA,sha256=TclDQSw8e5tzsTb-NVtKOIwazJQTf5p4YQEckTUO-0I,45048
-camel_ai-0.2.69a7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-camel_ai-0.2.69a7.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.69a7.dist-info/RECORD,,
+camel_ai-0.2.70.dist-info/METADATA,sha256=rcJwA1uI37kPW3D5P9jRroWihc_DLTbLGmyksOqCDew,45274
+camel_ai-0.2.70.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+camel_ai-0.2.70.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.70.dist-info/RECORD,,