camel-ai 0.2.71a9__tar.gz → 0.2.71a11__tar.gz

{camel_ai-0.2.71a9 → camel_ai-0.2.71a11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.71a9
+Version: 0.2.71a11
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -127,7 +127,7 @@ Requires-Dist: sympy<2,>=1.13.3; extra == 'all'
 Requires-Dist: tabulate>=0.9.0; extra == 'all'
 Requires-Dist: tavily-python<0.6,>=0.5.0; extra == 'all'
 Requires-Dist: textblob<0.18,>=0.17.1; extra == 'all'
-Requires-Dist: traceroot==0.0.3a2; extra == 'all'
+Requires-Dist: traceroot==0.0.3; extra == 'all'
 Requires-Dist: transformers<5,>=4; extra == 'all'
 Requires-Dist: tree-sitter-python<0.24,>=0.23.6; extra == 'all'
 Requires-Dist: tree-sitter<0.24,>=0.23.2; extra == 'all'
@@ -191,7 +191,7 @@ Requires-Dist: ipykernel<7,>=6.0.0; extra == 'dev-tools'
 Requires-Dist: jupyter-client<9,>=8.6.2; extra == 'dev-tools'
 Requires-Dist: langfuse>=2.60.5; extra == 'dev-tools'
 Requires-Dist: mcp>=1.3.0; extra == 'dev-tools'
-Requires-Dist: traceroot==0.0.3a2; extra == 'dev-tools'
+Requires-Dist: traceroot==0.0.3; extra == 'dev-tools'
 Requires-Dist: tree-sitter-python<0.24,>=0.23.6; extra == 'dev-tools'
 Requires-Dist: tree-sitter<0.24,>=0.23.2; extra == 'dev-tools'
 Requires-Dist: typer>=0.15.2; extra == 'dev-tools'

{camel_ai-0.2.71a9 → camel_ai-0.2.71a11}/camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.71a9'
+__version__ = '0.2.71a11'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.71a9 → camel_ai-0.2.71a11}/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_ai-0.2.71a9 → camel_ai-0.2.71a11}/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_ai-0.2.71a9 → camel_ai-0.2.71a11}/camel/societies/workforce/prompts.py

@@ -196,7 +196,11 @@ Now you should summarize the scenario and return the result of the task.
 """
 )
 
-WF_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 and parallelism:
+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 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.
 
 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.
@@ -216,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):
-    `<tasks><task>Do all research, analysis, and write final report.</task></tasks>`
+***
+**Example 1: Sequential Task for a Single Worker**
 
-*   Better decomposition (parallel structure):
+*   **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>Subtask 1 (ResearchAgent): Gather initial data and resources.</task>
-    <task>Subtask 2.1 (AnalysisAgent): Analyze Item A from Subtask 1 results.</task>
-    <task>Subtask 2.2 (AnalysisAgent): Analyze Item B from Subtask 1 results.</task>
-    <task>Subtask 2.N (AnalysisAgent): Analyze Item N from Subtask 1 results.</task>
-    <task>Subtask 3 (ReportAgent): Compile all analyses into 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:
 
@@ -261,10 +284,11 @@ You must return the subtasks as a list of individual subtasks within <tasks> tag
 </tasks>
 
 Each subtask should be:
-- Clear and concise
-- Achievable by a single worker
-- Contain all sequential steps that should be performed by the same worker type
-- Only separated from other subtasks when parallel execution by different worker types is beneficial
+- **Self-contained and independently understandable.**
+- Clear and concise.
+- Achievable by a single worker.
+- Containing all sequential steps that should be performed by the same worker type.
+- Written without any relative references (e.g., "the previous task").
 """
 
 FAILURE_ANALYSIS_PROMPT = TextPrompt(

{camel_ai-0.2.71a9 → camel_ai-0.2.71a11}/camel/societies/workforce/worker.py

@@ -87,15 +87,9 @@ class Worker(BaseNode, ABC):
                 f"{Fore.YELLOW}{self} get task {task.id}: {task.content}"
                 f"{Fore.RESET}"
             )
-            # Get the Task instance of dependencies
-            dependency_ids = await self._channel.get_dependency_ids()
-            task_dependencies = [
-                await self._channel.get_task_by_id(dep_id)
-                for dep_id in dependency_ids
-            ]
 
             # Process the task
-            task_state = await self._process_task(task, task_dependencies)
+            task_state = await self._process_task(task, [])
 
             # Update the result and status of the task
             task.set_state(task_state)

{camel_ai-0.2.71a9 → camel_ai-0.2.71a11}/camel/societies/workforce/workforce.py

@@ -44,7 +44,7 @@ from camel.societies.workforce.prompts import (
     ASSIGN_TASK_PROMPT,
     CREATE_NODE_PROMPT,
     FAILURE_ANALYSIS_PROMPT,
-    WF_TASK_DECOMPOSE_PROMPT,
+    TASK_DECOMPOSE_PROMPT,
 )
 from camel.societies.workforce.role_playing_worker import RolePlayingWorker
 from camel.societies.workforce.single_agent_worker import SingleAgentWorker
@@ -730,7 +730,7 @@ class Workforce(BaseNode):
             Union[List[Task], Generator[List[Task], None, None]]:
             The subtasks or generator of subtasks.
         """
-        decompose_prompt = WF_TASK_DECOMPOSE_PROMPT.format(
+        decompose_prompt = TASK_DECOMPOSE_PROMPT.format(
             content=task.content,
             child_nodes_info=self._get_child_nodes_info(),
             additional_info=task.additional_info,

{camel_ai-0.2.71a9 → camel_ai-0.2.71a11}/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