camel-ai 0.2.71a11__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

@@ -147,7 +147,7 @@ Here is the content of the parent task for you to refer to:
 Here are results of some prerequisite tasks that you can refer to:
 
 ==============================
-{dependency_task_info}
+{dependency_tasks_info}
 ==============================
 
 Here are some additional information about the task:
@@ -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."
+
+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.
 
-2.  **Aggressive Parallelization**:
+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/role_playing_worker.py

@@ -122,7 +122,7 @@ class RolePlayingWorker(Worker):
         prompt = ROLEPLAY_PROCESS_TASK_PROMPT.format(
             content=task.content,
             parent_task_content=task.parent.content if task.parent else "",
-            dependency_task_info=dependency_tasks_info,
+            dependency_tasks_info=dependency_tasks_info,
             additional_info=task.additional_info,
         )
         role_play_session = RolePlaying(

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/worker.py

@@ -89,7 +89,7 @@ class Worker(BaseNode, ABC):
             )
 
             # Process the task
-            task_state = await self._process_task(task, [])
+            task_state = await self._process_task(task, task.dependencies)
 
             # Update the result and status of the task
             task.set_state(task_state)

camel/societies/workforce/workforce.py

@@ -1008,7 +1008,7 @@ class Workforce(BaseNode):
         if not validate_task_content(new_content, task_id):
             logger.warning(
                 f"Task {task_id} content modification rejected: "
-                f"Invalid content. Content preview: '{new_content[:50]}...'"
+                f"Invalid content. Content preview: '{new_content}'"
             )
             return False
 
@@ -1194,7 +1194,7 @@ class Workforce(BaseNode):
             task.result = "Task failed: Invalid or empty content provided"
             logger.warning(
                 f"Task {task.id} rejected: Invalid or empty content. "
-                f"Content preview: '{task.content[:50]}...'"
+                f"Content preview: '{task.content}'"
             )
             return task
 
@@ -1327,7 +1327,7 @@ class Workforce(BaseNode):
             task.result = "Task failed: Invalid or empty content provided"
             logger.warning(
                 f"Task {task.id} rejected: Invalid or empty content. "
-                f"Content preview: '{task.content[:50]}...'"
+                f"Content preview: '{task.content}'"
             )
             return task
 
@@ -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.
@@ -1853,7 +1881,7 @@ class Workforce(BaseNode):
                 logger.error(
                     f"JSON parsing error in task assignment: Invalid response "
                     f"format - {e}. Response content: "
-                    f"{response.msg.content[:50]}..."
+                    f"{response.msg.content}"
                 )
                 return TaskAssignResult(assignments=[])
 
@@ -1985,6 +2013,37 @@ class Workforce(BaseNode):
 
         return final_assignments
 
+    def _update_task_dependencies_from_assignments(
+        self, assignments: List[TaskAssignment], tasks: List[Task]
+    ) -> None:
+        r"""Update Task.dependencies with actual Task objects based on
+        assignments.
+
+        Args:
+            assignments (List[TaskAssignment]): The task assignments
+                containing dependency IDs.
+            tasks (List[Task]): The tasks that were assigned.
+        """
+        # Create a lookup map for all available tasks
+        all_tasks = {}
+        for task_list in [self._completed_tasks, self._pending_tasks, tasks]:
+            for task in task_list:
+                all_tasks[task.id] = task
+
+        # Update dependencies for each assigned task
+        for assignment in assignments:
+            if not assignment.dependencies:
+                continue
+
+            matching_tasks = [t for t in tasks if t.id == assignment.task_id]
+            if matching_tasks:
+                task = matching_tasks[0]
+                task.dependencies = [
+                    all_tasks[dep_id]
+                    for dep_id in assignment.dependencies
+                    if dep_id in all_tasks
+                ]
+
     async def _find_assignee(
         self,
         tasks: List[Task],
@@ -2021,19 +2080,24 @@ class Workforce(BaseNode):
 
         # if all assignments are valid and all tasks are assigned, return early
         if not invalid_assignments and not unassigned_tasks:
+            self._update_task_dependencies_from_assignments(
+                valid_assignments, tasks
+            )
             return TaskAssignResult(assignments=valid_assignments)
 
-        # handle retry and fallback for
-        # invalid assignments and unassigned tasks
-        all_problem_assignments = invalid_assignments
+        # handle retry and fallback for invalid assignments and unassigned
+        # tasks
         retry_and_fallback_assignments = (
             await self._handle_assignment_retry_and_fallback(
-                all_problem_assignments, tasks, valid_worker_ids
+                invalid_assignments, tasks, valid_worker_ids
             )
         )
-        valid_assignments.extend(retry_and_fallback_assignments)
+        all_assignments = valid_assignments + retry_and_fallback_assignments
+
+        # Update Task.dependencies for all final assignments
+        self._update_task_dependencies_from_assignments(all_assignments, tasks)
 
-        return TaskAssignResult(assignments=valid_assignments)
+        return TaskAssignResult(assignments=all_assignments)
 
     async def _post_task(self, task: Task, assignee_id: str) -> None:
         # Record the start time when a task is posted
@@ -2107,7 +2171,7 @@ class Workforce(BaseNode):
                 )
                 new_node_conf = WorkerConf(
                     description=f"Fallback worker for task: "
-                    f"{task.content[:50]}...",
+                    f"{task.content}",
                     role="General Assistant",
                     sys_msg="You are a general assistant that can help "
                     "with various tasks.",
@@ -2117,8 +2181,7 @@ class Workforce(BaseNode):
                     response.msg.content,
                     schema=WorkerConf,
                     fallback_values={
-                        "description": f"Worker for task: "
-                        f"{task.content[:50]}...",
+                        "description": f"Worker for task: " f"{task.content}",
                         "role": "Task Specialist",
                         "sys_msg": f"You are a specialist for: {task.content}",
                     },
@@ -2130,7 +2193,7 @@ class Workforce(BaseNode):
                     new_node_conf = WorkerConf(**result)
                 else:
                     new_node_conf = WorkerConf(
-                        description=f"Worker for task: {task.content[:50]}...",
+                        description=f"Worker for task: {task.content}",
                         role="Task Specialist",
                         sys_msg=f"You are a specialist for: {task.content}",
                     )
@@ -2147,7 +2210,7 @@ class Workforce(BaseNode):
                 # Create a fallback worker configuration
                 new_node_conf = WorkerConf(
                     description=f"Fallback worker for "
-                    f"task: {task.content[:50]}...",
+                    f"task: {task.content}",
                     role="General Assistant",
                     sys_msg="You are a general assistant that can help "
                     "with various tasks.",
@@ -2160,7 +2223,7 @@ class Workforce(BaseNode):
                     logger.error(
                         f"JSON parsing error in worker creation: Invalid "
                         f"response format - {e}. Response content: "
-                        f"{response.msg.content[:100]}..."
+                        f"{response.msg.content}"
                     )
                     raise RuntimeError(
                         f"Failed to create worker for task {task.id}: "
@@ -2364,7 +2427,7 @@ class Workforce(BaseNode):
                 f"Task {task.id} has exceeded maximum retry attempts "
                 f"({MAX_TASK_RETRIES}). Final failure "
                 f"reason: {detailed_error}. "
-                f"Task content: '{task.content[:100]}...'"
+                f"Task content: '{task.content}'"
             )
             self._cleanup_task_tracking(task.id)
             # Mark task as completed for dependency tracking before halting
@@ -2793,7 +2856,7 @@ class Workforce(BaseNode):
                     # useful results
                     if is_task_result_insufficient(returned_task):
                         result_preview = (
-                            returned_task.result[:100] + "..."
+                            returned_task.result
                             if returned_task.result
                             else "No result"
                         )

camel/storages/vectordb_storages/__init__.py

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