camel-ai 0.2.71a10__py3-none-any.whl → 0.2.71a12__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.71a10'
+__version__ = '0.2.71a12'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -1236,7 +1236,7 @@ class ChatAgent(BaseAgent):
                     if not message.parsed:
                         logger.warning(
                             f"Failed to parse JSON from response: "
-                            f"{content[:100]}..."
+                            f"{content}"
                         )
 
                 except Exception as e:

camel/models/cohere_model.py

@@ -21,7 +21,10 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
 from pydantic import BaseModel
 
 if TYPE_CHECKING:
-    from cohere.types import ChatMessageV2, ChatResponse
+    from cohere.types import (  # type: ignore[attr-defined]
+        ChatMessageV2,
+        ChatResponse,
+    )
 
 from camel.configs import COHERE_API_PARAMS, CohereConfig
 from camel.messages import OpenAIMessage

camel/models/moonshot_model.py

@@ -29,8 +29,23 @@ from camel.types import (
 from camel.utils import (
     BaseTokenCounter,
     api_keys_required,
+    get_current_agent_session_id,
+    update_langfuse_trace,
 )
 
+if os.environ.get("LANGFUSE_ENABLED", "False").lower() == "true":
+    try:
+        from langfuse.decorators import observe
+    except ImportError:
+        from camel.utils import observe
+elif os.environ.get("TRACEROOT_ENABLED", "False").lower() == "true":
+    try:
+        from traceroot import trace as observe  # type: ignore[import]
+    except ImportError:
+        from camel.utils import observe
+else:
+    from camel.utils import observe
+
 
 class MoonshotModel(OpenAICompatibleModel):
     r"""Moonshot API in a unified OpenAICompatibleModel interface.
@@ -91,13 +106,51 @@ class MoonshotModel(OpenAICompatibleModel):
             **kwargs,
         )
 
+    @observe()
     async def _arun(
         self,
         messages: List[OpenAIMessage],
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
     ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
-        raise NotImplementedError("Moonshot does not support async inference.")
+        r"""Runs inference of Moonshot chat completion asynchronously.
+
+        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:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+        """
+
+        # Update Langfuse trace with current agent session and metadata
+        agent_session_id = get_current_agent_session_id()
+        if agent_session_id:
+            update_langfuse_trace(
+                session_id=agent_session_id,
+                metadata={
+                    "agent_id": agent_session_id,
+                    "model_type": str(self.model_type),
+                },
+                tags=["CAMEL-AI", str(self.model_type)],
+            )
+
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
 
     def check_model_config(self):
         r"""Check whether the model configuration contains any

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:
@@ -198,7 +198,7 @@ Now you should summarize the scenario and return the result of the task.
 
 TASK_DECOMPOSE_PROMPT = r"""You need to decompose the given task into subtasks according to the workers available in the group, following these important principles to maximize efficiency, parallelism, and clarity for the executing agents:
 
-1.  **Self-Contained Subtasks**: This is the most critical principle. Each subtask's description **must be fully self-sufficient and independently understandable**. The agent executing the subtask has **no knowledge** of the parent task, other subtasks, or the overall workflow.
+1.  **Self-Contained Subtasks**: This is critical principle. Each subtask's description **must be fully self-sufficient and independently understandable**. The agent executing the subtask has **no knowledge** of the parent task, other subtasks, or the overall workflow.
     *   **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.
 
@@ -220,23 +220,42 @@ These principles aim to reduce overall completion time by maximizing concurrent
 
 **EXAMPLE FORMAT ONLY** (DO NOT use this example content for actual task decomposition):
 
-If given a hypothetical task requiring research, analysis, and reporting with multiple items to process, you should decompose it to maximize parallelism:
-
-*   Poor decomposition (monolithic and vague):
-    `<tasks><task>Do all research, analysis, and write final report.</task></tasks>`
+***
+**Example 1: Sequential Task for a Single Worker**
 
-*   **Excellent decomposition (self-contained and parallel)**:
+*   **Overall Task**: "Create a short blog post about the benefits of Python. First, research the key benefits. Then, write a 300-word article. Finally, find a suitable image to go with it."
+*   **Available Workers**:
+    *   `Document Agent`: A worker that can research topics, write articles, and find images.
+*   **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>
+    </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.
+
+***
+**Example 2: Parallel Task Across Different Workers**
+
+*   **Overall Task**: "Write a report on the Q2 performance of Apple (AAPL) and Google (GOOGL). The report needs a financial summary and a market sentiment analysis for each company."
+*   **Available Workers**:
+    *   `financial_analyst_1`: A worker that can analyze financial data and create summaries.
+    *   `market_researcher_1`: A worker that can perform market sentiment analysis.
+    *   `report_writer_1`: A worker that compiles information into a final report.
+*   **Correct Decomposition**:
+    ```xml
     <tasks>
-    <task>(ResearchAgent): Gather data and resources on topic X, producing a list of relevant items.</task>
-    <task>(AnalysisAgent): Analyze the provided document 'Item A'.</task>
-    <task>(AnalysisAgent): Analyze the provided document 'Item B'.</task>
-    <task>(AnalysisAgent): Analyze the provided document 'Item N'.</task>
-    <task>(ReportAgent): Compile the provided analyses of items A, B, and N into a final report.</task>
+    <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>
     </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.
+***
 
-**END OF FORMAT EXAMPLE** - Now apply this structure to your actual task below.
+**END OF EXAMPLES** - Now, apply these principles and examples to decompose the following task.
 
 The content of the task is:
 

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/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
 
@@ -1853,7 +1853,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 +1985,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 +2052,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 +2143,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 +2153,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 +2165,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 +2182,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 +2195,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 +2399,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 +2828,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/tasks/task.py

@@ -99,7 +99,7 @@ def validate_task_content(
         logger.warning(
             f"Task {task_id}: Content too short ({len(stripped_content)} "
             f"chars < {min_length} minimum). Content preview: "
-            f"'{stripped_content[:50]}...'"
+            f"'{stripped_content}'"
         )
         return False
 
@@ -124,7 +124,7 @@ def validate_task_content(
         if any(indicator in content_lower for indicator in failure_indicators):
             logger.warning(
                 f"Task {task_id}: Failure indicator detected in result. "
-                f"Content preview: '{stripped_content[:100]}...'"
+                f"Content preview: '{stripped_content}'"
             )
             return False
 
@@ -132,7 +132,7 @@ def validate_task_content(
         if content_lower.startswith(("error", "failed", "cannot", "unable")):
             logger.warning(
                 f"Task {task_id}: Error/refusal pattern detected at start. "
-                f"Content preview: '{stripped_content[:100]}...'"
+                f"Content preview: '{stripped_content}'"
             )
             return False
 
@@ -195,7 +195,7 @@ def parse_response(
             logger.warning(
                 f"Skipping invalid subtask {task_id}.{i} "
                 f"during decomposition: "
-                f"Content '{stripped_content[:50]}...' failed validation"
+                f"Content '{stripped_content}' failed validation"
             )
     return tasks
 
@@ -233,6 +233,8 @@ class Task(BaseModel):
             (default: :obj:`0`)
         assigned_worker_id (Optional[str]): The ID of the worker assigned to
             this task. (default: :obj:`None`)
+        dependencies (List[Task]): The dependencies for the task.
+            (default: :obj:`[]`)
         additional_info (Optional[Dict[str, Any]]): Additional information for
             the task. (default: :obj:`None`)
         image_list (Optional[List[Image.Image]]): Optional list of PIL Image
@@ -265,6 +267,8 @@ class Task(BaseModel):
 
     assigned_worker_id: Optional[str] = None
 
+    dependencies: List["Task"] = []
+
     additional_info: Optional[Dict[str, Any]] = None
 
     image_list: Optional[List[Image.Image]] = None
@@ -530,7 +534,7 @@ class Task(BaseModel):
                 logger.warning(
                     f"Skipping invalid subtask {task_id}.{i} "
                     f"during streaming decomposition: "
-                    f"Content '{stripped_content[:50]}...' failed validation"
+                    f"Content '{stripped_content}' failed validation"
                 )
         return tasks
 

camel/toolkits/function_tool.py

@@ -256,11 +256,24 @@ def sanitize_and_enforce_required(parameters_dict):
                 # This field is optional - add null to its type
                 current_type = field_schema.get('type')
                 has_ref = '$ref' in field_schema
+                has_any_of = 'anyOf' in field_schema
 
                 if has_ref:
                     # Fields with $ref shouldn't have additional type field
                     # The $ref itself defines the type structure
                     pass
+                elif has_any_of:
+                    # Field already has anyOf
+                    any_of_types = field_schema['anyOf']
+                    has_null_type = any(
+                        item.get('type') == 'null' for item in any_of_types
+                    )
+                    if not has_null_type:
+                        # Add null type to anyOf
+                        field_schema['anyOf'].append({'type': 'null'})
+                    # Remove conflicting type field if it exists
+                    if 'type' in field_schema:
+                        del field_schema['type']
                 elif current_type:
                     if isinstance(current_type, str):
                         # Single type - convert to array with null