camel-ai 0.2.71a12__py3-none-any.whl → 0.2.72__py3-none-any.whl

camel/memories/agent_memories.py

@@ -88,6 +88,45 @@ class ChatHistoryMemory(AgentMemory):
     def clear(self) -> None:
         self._chat_history_block.clear()
 
+    def clean_tool_calls(self) -> None:
+        r"""Removes tool call messages from memory.
+        This method removes all FUNCTION/TOOL role messages and any ASSISTANT
+        messages that contain tool_calls in their meta_dict to save token
+        usage.
+        """
+        from camel.types import OpenAIBackendRole
+
+        # Get all messages from storage
+        record_dicts = self._chat_history_block.storage.load()
+        if not record_dicts:
+            return
+
+        # Track indices to remove (reverse order for efficient deletion)
+        indices_to_remove = []
+
+        # Identify indices of tool-related messages
+        for i, record in enumerate(record_dicts):
+            role = record.get('role_at_backend')
+
+            # Mark FUNCTION messages for removal
+            if role == OpenAIBackendRole.FUNCTION.value:
+                indices_to_remove.append(i)
+            # Mark TOOL messages for removal
+            elif role == OpenAIBackendRole.TOOL.value:
+                indices_to_remove.append(i)
+            # Mark ASSISTANT messages with tool_calls for removal
+            elif role == OpenAIBackendRole.ASSISTANT.value:
+                meta_dict = record.get('meta_dict', {})
+                if meta_dict and 'tool_calls' in meta_dict:
+                    indices_to_remove.append(i)
+
+        # Remove records in-place
+        for i in reversed(indices_to_remove):
+            del record_dicts[i]
+
+        # Save the modified records back to storage
+        self._chat_history_block.storage.save(record_dicts)
+
 
 class VectorDBMemory(AgentMemory):
     r"""An agent memory wrapper of :obj:`VectorDBBlock`. This memory queries

camel/memories/base.py

@@ -149,6 +149,14 @@ class AgentMemory(MemoryBlock, ABC):
         """
         return self.get_context_creator().create_context(self.retrieve())
 
+    def clean_tool_calls(self) -> None:
+        r"""Removes tool call messages from memory.
+        This is an optional method that can be overridden by subclasses
+        to implement cleaning of tool-related messages. By default, it
+        does nothing, maintaining backward compatibility.
+        """
+        pass
+
     def __repr__(self) -> str:
         r"""Returns a string representation of the AgentMemory.
 

camel/models/gemini_model.py

@@ -243,7 +243,7 @@ class GeminiModel(OpenAICompatibleModel):
                 function_dict = tool.get('function', {})
                 function_dict.pop("strict", None)
 
-                # Process parameters to remove anyOf
+                # Process parameters to remove anyOf and handle enum/format
                 if 'parameters' in function_dict:
                     params = function_dict['parameters']
                     if 'properties' in params:
@@ -260,6 +260,20 @@ class GeminiModel(OpenAICompatibleModel):
                                         'description'
                                     ] = prop_value['description']
 
+                            # Handle enum and format restrictions for Gemini
+                            # API enum: only allowed for string type
+                            if prop_value.get('type') != 'string':
+                                prop_value.pop('enum', None)
+
+                            # format: only allowed for string, integer, and
+                            # number types
+                            if prop_value.get('type') not in [
+                                'string',
+                                'integer',
+                                'number',
+                            ]:
+                                prop_value.pop('format', None)
+
             request_config["tools"] = tools
 
         return self._client.chat.completions.create(
@@ -283,7 +297,7 @@ class GeminiModel(OpenAICompatibleModel):
                 function_dict = tool.get('function', {})
                 function_dict.pop("strict", None)
 
-                # Process parameters to remove anyOf
+                # Process parameters to remove anyOf and handle enum/format
                 if 'parameters' in function_dict:
                     params = function_dict['parameters']
                     if 'properties' in params:
@@ -300,6 +314,20 @@ class GeminiModel(OpenAICompatibleModel):
                                         'description'
                                     ] = prop_value['description']
 
+                            # Handle enum and format restrictions for Gemini
+                            # API enum: only allowed for string type
+                            if prop_value.get('type') != 'string':
+                                prop_value.pop('enum', None)
+
+                            # format: only allowed for string, integer, and
+                            # number types
+                            if prop_value.get('type') not in [
+                                'string',
+                                'integer',
+                                'number',
+                            ]:
+                                prop_value.pop('format', None)
+
             request_config["tools"] = tools
 
         return await self._async_client.chat.completions.create(

camel/models/moonshot_model.py

@@ -20,6 +20,7 @@ from pydantic import BaseModel
 
 from camel.configs import MOONSHOT_API_PARAMS, MoonshotConfig
 from camel.messages import OpenAIMessage
+from camel.models._utils import try_modify_message_with_format
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.types import (
     ChatCompletion,
@@ -106,6 +107,38 @@ class MoonshotModel(OpenAICompatibleModel):
             **kwargs,
         )
 
+    def _prepare_request(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        r"""Prepare the request configuration for Moonshot API.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
+
+        Returns:
+            Dict[str, Any]: The prepared request configuration.
+        """
+        import copy
+
+        request_config = copy.deepcopy(self.model_config_dict)
+
+        if tools:
+            request_config["tools"] = tools
+        elif response_format:
+            # Use the same approach as DeepSeek for structured output
+            try_modify_message_with_format(messages[-1], response_format)
+            request_config["response_format"] = {"type": "json_object"}
+
+        return request_config
+
     @observe()
     async def _arun(
         self,
@@ -141,10 +174,9 @@ class MoonshotModel(OpenAICompatibleModel):
                 tags=["CAMEL-AI", str(self.model_type)],
             )
 
-        request_config = self.model_config_dict.copy()
-
-        if tools:
-            request_config["tools"] = tools
+        request_config = self._prepare_request(
+            messages, response_format, tools
+        )
 
         return await self._async_client.chat.completions.create(
             messages=messages,

camel/models/openai_model.py

@@ -23,6 +23,7 @@ from openai.lib.streaming.chat import (
 from pydantic import BaseModel
 
 from camel.configs import OPENAI_API_PARAMS, ChatGPTConfig
+from camel.logger import get_logger
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import (
@@ -39,6 +40,8 @@ from camel.utils import (
     update_langfuse_trace,
 )
 
+logger = get_logger(__name__)
+
 if os.environ.get("LANGFUSE_ENABLED", "False").lower() == "true":
     try:
         from langfuse.decorators import observe
@@ -273,17 +276,23 @@ class OpenAIModel(BaseModelBackend):
 
         # Update Langfuse trace with current agent session and metadata
         agent_session_id = get_current_agent_session_id()
+        model_type_str = str(self.model_type)
+        if not agent_session_id:
+            agent_session_id = "no-session-id"
+        metadata = {
+            "source": "camel",
+            "agent_id": agent_session_id,
+            "agent_type": "camel_chat_agent",
+            "model_type": model_type_str,
+        }
+        metadata = {k: str(v) for k, v in metadata.items()}
         if agent_session_id:
             update_langfuse_trace(
                 session_id=agent_session_id,
-                metadata={
-                    "source": "camel",
-                    "agent_id": agent_session_id,
-                    "agent_type": "camel_chat_agent",
-                    "model_type": str(self.model_type),
-                },
-                tags=["CAMEL-AI", str(self.model_type)],
+                metadata=metadata,
+                tags=["CAMEL-AI", model_type_str],
             )
+        logger.info(f"metadata: {metadata}")
 
         messages = self._adapt_messages_for_o1_models(messages)
         response_format = response_format or self.model_config_dict.get(
@@ -342,17 +351,22 @@ class OpenAIModel(BaseModelBackend):
 
         # Update Langfuse trace with current agent session and metadata
         agent_session_id = get_current_agent_session_id()
-        if agent_session_id:
+        model_type_str = str(self.model_type)
+        if not agent_session_id:
+            agent_session_id = "no-session-id"
+            metadata = {
+                "source": "camel",
+                "agent_id": agent_session_id,
+                "agent_type": "camel_chat_agent",
+                "model_type": model_type_str,
+            }
+            metadata = {k: str(v) for k, v in metadata.items()}
             update_langfuse_trace(
                 session_id=agent_session_id,
-                metadata={
-                    "source": "camel",
-                    "agent_id": agent_session_id,
-                    "agent_type": "camel_chat_agent",
-                    "model_type": str(self.model_type),
-                },
-                tags=["CAMEL-AI", str(self.model_type)],
+                metadata=metadata,
+                tags=["CAMEL-AI", model_type_str],
             )
+        logger.info(f"metadata: {metadata}")
 
         messages = self._adapt_messages_for_o1_models(messages)
         response_format = response_format or self.model_config_dict.get(

camel/societies/workforce/prompts.py

@@ -202,16 +202,21 @@ TASK_DECOMPOSE_PROMPT = r"""You need to decompose the given task into subtasks a
     *   **DO NOT** use relative references like "the first task," "the paper mentioned above," or "the result from the previous step."
     *   **DO** write explicit instructions. For example, instead of "Analyze the document," write "Analyze the document titled 'The Future of AI'." The system will automatically provide the necessary inputs (like the document itself) from previous steps.
 
-1.  **Strategic Grouping for Sequential Work**:
-    *   If a series of steps must be done in order *and* can be handled by the same worker type, group them into a single subtask to maintain flow and minimize handoffs.
+2.  **Define Clear Deliverables**: Each subtask must specify a clear, concrete deliverable. This tells the agent exactly what to produce and provides a clear "definition of done."
+    *   **DO NOT** use vague verbs like "analyze," "look into," or "research" without defining the output.
+    *   **DO** specify the format and content of the output. For example, instead of "Analyze the attached report," write "Summarize the key findings of the attached report in a 3-bullet-point list." Instead of "Find contacts," write "Extract all names and email addresses from the document and return them as a JSON list of objects, where each object has a 'name' and 'email' key."
 
-2.  **Aggressive Parallelization**:
+3.  **Full Workflow Completion & Strategic Grouping**:
+    *   **Preserve the Entire Goal**: Ensure the decomposed subtasks collectively achieve the *entire* original task. Do not drop or ignore final steps like sending a message, submitting a form, or creating a file.
+    *   **Group Sequential Actions**: If a series of steps must be done in order *and* can be handled by the same worker type (e.g., read, think, reply), group them into a single, comprehensive subtask. This maintains workflow and ensures the final goal is met.
+
+4.  **Aggressive Parallelization**:
     *   **Across Different Worker Specializations**: If distinct phases of the overall task require different types of workers (e.g., research by a 'SearchAgent', then content creation by a 'DocumentAgent'), define these as separate subtasks.
     *   **Within a Single Phase (Data/Task Parallelism)**: If a phase involves repetitive operations on multiple items (e.g., processing 10 documents, fetching 5 web pages, analyzing 3 datasets):
         *   Decompose this into parallel subtasks, one for each item or a small batch of items.
         *   This applies even if the same type of worker handles these parallel subtasks. The goal is to leverage multiple available workers or allow concurrent processing.
 
-3.  **Subtask Design for Efficiency**:
+5.  **Subtask Design for Efficiency**:
     *   **Actionable and Well-Defined**: Each subtask should have a clear, achievable goal.
     *   **Balanced Granularity**: Make subtasks large enough to be meaningful but small enough to enable parallelism and quick feedback. Avoid overly large subtasks that hide parallel opportunities.
     *   **Consider Dependencies**: While you list tasks sequentially, think about the true dependencies. The workforce manager will handle execution based on these implied dependencies and worker availability.
@@ -229,10 +234,10 @@ These principles aim to reduce overall completion time by maximizing concurrent
 *   **Correct Decomposition**:
     ```xml
     <tasks>
-    <task>Create a short blog post about the benefits of Python by researching key benefits, writing a 300-word article, and finding a suitable image.</task>
+    <task>Create a short blog post about the benefits of Python by researching key benefits, writing a 300-word article, and finding a suitable image. The final output should be a single string containing the 300-word article followed by the image URL.</task>
     </tasks>
     ```
-*   **Reasoning**: All steps are sequential and can be handled by the same worker type (`Document Agent`). Grouping them into one subtask is efficient and maintains the workflow, following the "Strategic Grouping" principle.
+*   **Reasoning**: All steps are sequential and can be handled by the same worker type (`Document Agent`). Grouping them into one subtask is efficient and maintains the workflow, following the "Strategic Grouping" principle. **The deliverable is clearly defined as a single string.**
 
 ***
 **Example 2: Parallel Task Across Different Workers**
@@ -245,14 +250,14 @@ These principles aim to reduce overall completion time by maximizing concurrent
 *   **Correct Decomposition**:
     ```xml
     <tasks>
-    <task>Create a financial summary for Apple (AAPL) for Q2.</task>
-    <task>Create a financial summary for Google (GOOGL) for Q2.</task>
-    <task>Perform market sentiment analysis for Apple (AAPL) for Q2.</task>
-    <task>Perform market sentiment analysis for Google (GOOGL) for Q2.</task>
-    <task>Compile the provided financial summaries and market sentiment analyses for Apple (AAPL) and Google (GOOGL) into a single Q2 performance report.</task>
+    <task>Create a 1-paragraph financial summary for Apple (AAPL) for Q2, covering revenue, net income, and EPS. The output must be a plain text paragraph.</task>
+    <task>Create a 1-paragraph financial summary for Google (GOOGL) for Q2, covering revenue, net income, and EPS. The output must be a plain text paragraph.</task>
+    <task>Perform a market sentiment analysis for Apple (AAPL) for Q2, returning a single sentiment score from -1 (very negative) to 1 (very positive). The output must be a single floating-point number.</task>
+    <task>Perform a market sentiment analysis for Google (GOOGL) for Q2, returning a single sentiment score from -1 (very negative) to 1 (very positive). The output must be a single floating-point number.</task>
+    <task>Compile the provided financial summaries and market sentiment scores for Apple (AAPL) and Google (GOOGL) into a single Q2 performance report. The report should be a markdown-formatted document.</task>
     </tasks>
     ```
-*   **Reasoning**: The financial analysis and market research can be done in parallel for both companies. The final report depends on all previous steps. This decomposition leverages worker specialization and parallelism, following the "Aggressive Parallelization" principle.
+*   **Reasoning**: The financial analysis and market research can be done in parallel for both companies. The final report depends on all previous steps. This decomposition leverages worker specialization and parallelism, following the "Aggressive Parallelization" principle. **Each subtask has a clearly defined deliverable.**
 ***
 
 **END OF EXAMPLES** - Now, apply these principles and examples to decompose the following task.
@@ -312,6 +317,8 @@ Additional Info: {additional_info}
 2. **REPLAN**: Modify the task content to address the underlying issue
    - Use for: Unclear requirements, insufficient context, correctable errors
    - Provide: Modified task content that addresses the failure cause
+   - **CRITICAL**: The replanned task MUST be a clear, actionable
+     instruction for an AI agent, not a question or request for a human.
 
 3. **DECOMPOSE**: Break the task into smaller, more manageable subtasks
    - Use for: Complex tasks, capability mismatches, persistent failures
@@ -324,10 +331,13 @@ Additional Info: {additional_info}
 
 - **Connection/Network Errors**: Almost always choose RETRY
 - **Model Processing Errors**: Consider REPLAN if the task can be clarified, otherwise DECOMPOSE
-- **Capability Gaps**: Choose DECOMPOSE to break into simpler parts
+- **Capability Gaps**: Choose DECOMPOSE to break into simpler parts. If a
+  replan can work, ensure the new task is a command for an agent, not a
+  request to a user.
 - **Ambiguous Requirements**: Choose REPLAN with clearer instructions
 - **High Failure Count**: Lean towards DECOMPOSE rather than repeated retries
-- **Deep Tasks (depth > 2)**: Prefer RETRY or REPLAN over further decomposition
+- **Deep Tasks (depth > 2)**: Prefer RETRY or REPLAN over further
+  decomposition
 
 **RESPONSE FORMAT:**
 You must return a valid JSON object with these fields:

camel/societies/workforce/single_agent_worker.py

@@ -410,11 +410,13 @@ class SingleAgentWorker(Worker):
             f"{getattr(worker_agent, 'agent_id', worker_agent.role_name)} "
             f"(from pool/clone of "
             f"{getattr(self.worker, 'agent_id', self.worker.role_name)}) "
-            f"to process task {task.content}",
-            "response_content": response_content,
-            "tool_calls": final_response.info.get("tool_calls")
-            if isinstance(response, AsyncStreamingChatAgentResponse)
-            else response.info.get("tool_calls"),
+            f"to process task: {task.content}",
+            "response_content": response_content[:50],
+            "tool_calls": str(
+                final_response.info.get("tool_calls")
+                if isinstance(response, AsyncStreamingChatAgentResponse)
+                else response.info.get("tool_calls")
+            )[:50],
             "total_tokens": total_tokens,
         }
 
@@ -445,11 +447,11 @@ class SingleAgentWorker(Worker):
             f"\n{color}{task_result.content}{Fore.RESET}\n======",  # type: ignore[union-attr]
         )
 
+        task.result = task_result.content  # type: ignore[union-attr]
+
         if task_result.failed:  # type: ignore[union-attr]
             return TaskState.FAILED
 
-        task.result = task_result.content  # type: ignore[union-attr]
-
         if is_task_result_insufficient(task):
             print(
                 f"{Fore.RED}Task {task.id}: Content validation failed - "

camel/societies/workforce/workforce.py

@@ -1721,23 +1721,51 @@ class Workforce(BaseNode):
 
     def _get_child_nodes_info(self) -> str:
         r"""Get the information of all the child nodes under this node."""
-        info = ""
-        for child in self._children:
-            if isinstance(child, Workforce):
-                additional_info = "A Workforce node"
-            elif isinstance(child, SingleAgentWorker):
-                additional_info = "tools: " + (
-                    ", ".join(child.worker.tool_dict.keys())
-                )
-            elif isinstance(child, RolePlayingWorker):
-                additional_info = "A Role playing node"
+        return "".join(
+            f"<{child.node_id}>:<{child.description}>:<{self._get_node_info(child)}>\n"
+            for child in self._children
+        )
+
+    def _get_node_info(self, node) -> str:
+        r"""Get descriptive information for a specific node type."""
+        if isinstance(node, Workforce):
+            return "A Workforce node"
+        elif isinstance(node, SingleAgentWorker):
+            return self._get_single_agent_info(node)
+        elif isinstance(node, RolePlayingWorker):
+            return "A Role playing node"
+        else:
+            return "Unknown node"
+
+    def _get_single_agent_info(self, worker: 'SingleAgentWorker') -> str:
+        r"""Get formatted information for a SingleAgentWorker node."""
+        toolkit_tools = self._group_tools_by_toolkit(worker.worker.tool_dict)
+
+        if not toolkit_tools:
+            return "no tools available"
+
+        toolkit_info = []
+        for toolkit_name, tools in sorted(toolkit_tools.items()):
+            tools_str = ', '.join(sorted(tools))
+            toolkit_info.append(f"{toolkit_name}({tools_str})")
+
+        return " | ".join(toolkit_info)
+
+    def _group_tools_by_toolkit(self, tool_dict: dict) -> dict[str, list[str]]:
+        r"""Group tools by their parent toolkit class names."""
+        toolkit_tools: dict[str, list[str]] = {}
+
+        for tool_name, tool in tool_dict.items():
+            if hasattr(tool.func, '__self__'):
+                toolkit_name = tool.func.__self__.__class__.__name__
             else:
-                additional_info = "Unknown node"
-            info += (
-                f"<{child.node_id}>:<{child.description}>:<"
-                f"{additional_info}>\n"
-            )
-        return info
+                toolkit_name = "Standalone"
+
+            if toolkit_name not in toolkit_tools:
+                toolkit_tools[toolkit_name] = []
+            toolkit_tools[toolkit_name].append(tool_name)
+
+        return toolkit_tools
 
     def _get_valid_worker_ids(self) -> set:
         r"""Get all valid worker IDs from child nodes.

camel/storages/vectordb_storages/__init__.py

@@ -42,4 +42,5 @@ __all__ = [
     'VectorRecord',
     'VectorDBStatus',
     'PgVectorStorage',
+    'SurrealStorage',
 ]