camel-ai 0.2.71a4__py3-none-any.whl → 0.2.71a5__py3-none-any.whl

camel/models/openai_compatible_model.py

@@ -17,6 +17,10 @@ from json import JSONDecodeError
 from typing import Any, Dict, List, Optional, Type, Union
 
 from openai import AsyncOpenAI, AsyncStream, BadRequestError, OpenAI, Stream
+from openai.lib.streaming.chat import (
+    AsyncChatCompletionStreamManager,
+    ChatCompletionStreamManager,
+)
 from pydantic import BaseModel, ValidationError
 
 from camel.logger import get_logger
@@ -41,6 +45,11 @@ if os.environ.get("LANGFUSE_ENABLED", "False").lower() == "true":
         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
 
@@ -138,7 +147,11 @@ class OpenAICompatibleModel(BaseModelBackend):
         messages: List[OpenAIMessage],
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+    ) -> Union[
+        ChatCompletion,
+        Stream[ChatCompletionChunk],
+        ChatCompletionStreamManager[BaseModel],
+    ]:
         r"""Runs inference of OpenAI chat completion.
 
         Args:
@@ -153,6 +166,8 @@ class OpenAICompatibleModel(BaseModelBackend):
             Union[ChatCompletion, Stream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
+                `ChatCompletionStreamManager[BaseModel]` for
+                structured output streaming.
         """
 
         # Update Langfuse trace with current agent session and metadata
@@ -170,10 +185,22 @@ class OpenAICompatibleModel(BaseModelBackend):
         response_format = response_format or self.model_config_dict.get(
             "response_format", None
         )
+
+        # Check if streaming is enabled
+        is_streaming = self.model_config_dict.get("stream", False)
+
         if response_format:
             result: Union[ChatCompletion, Stream[ChatCompletionChunk]] = (
                 self._request_parse(messages, response_format, tools)
             )
+            if is_streaming:
+                # Use streaming parse for structured output
+                return self._request_stream_parse(
+                    messages, response_format, tools
+                )
+            else:
+                # Use non-streaming parse for structured output
+                return self._request_parse(messages, response_format, tools)
         else:
             result = self._request_chat_completion(messages, tools)
 
@@ -185,7 +212,11 @@ class OpenAICompatibleModel(BaseModelBackend):
         messages: List[OpenAIMessage],
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+    ) -> Union[
+        ChatCompletion,
+        AsyncStream[ChatCompletionChunk],
+        AsyncChatCompletionStreamManager[BaseModel],
+    ]:
         r"""Runs inference of OpenAI chat completion in async mode.
 
         Args:
@@ -197,9 +228,12 @@ class OpenAICompatibleModel(BaseModelBackend):
                 use for the request.
 
         Returns:
-            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
-                `ChatCompletion` in the non-stream mode, or
-                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk],
+                AsyncChatCompletionStreamManager[BaseModel]]:
+                `ChatCompletion` in the non-stream mode,
+                `AsyncStream[ChatCompletionChunk]` in the stream mode,
+                or `AsyncChatCompletionStreamManager[BaseModel]` for
+                structured output streaming.
         """
 
         # Update Langfuse trace with current agent session and metadata
@@ -217,10 +251,24 @@ class OpenAICompatibleModel(BaseModelBackend):
         response_format = response_format or self.model_config_dict.get(
             "response_format", None
         )
+
+        # Check if streaming is enabled
+        is_streaming = self.model_config_dict.get("stream", False)
+
         if response_format:
             result: Union[
                 ChatCompletion, AsyncStream[ChatCompletionChunk]
             ] = await self._arequest_parse(messages, response_format, tools)
+            if is_streaming:
+                # Use streaming parse for structured output
+                return await self._arequest_stream_parse(
+                    messages, response_format, tools
+                )
+            else:
+                # Use non-streaming parse for structured output
+                return await self._arequest_parse(
+                    messages, response_format, tools
+                )
         else:
             result = await self._arequest_chat_completion(messages, tools)
 
@@ -336,6 +384,62 @@ class OpenAICompatibleModel(BaseModelBackend):
                 logger.error(f"Fallback attempt also failed: {e}")
                 raise
 
+    def _request_stream_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletionStreamManager[BaseModel]:
+        r"""Request streaming structured output parsing.
+
+        Note: This uses OpenAI's beta streaming API for structured outputs.
+        """
+        import copy
+
+        request_config = copy.deepcopy(self.model_config_dict)
+
+        # Remove stream from config as it's handled by the stream method
+        request_config.pop("stream", None)
+
+        if tools is not None:
+            request_config["tools"] = tools
+
+        # Use the beta streaming API for structured outputs
+        return self._client.beta.chat.completions.stream(
+            messages=messages,
+            model=self.model_type,
+            response_format=response_format,
+            **request_config,
+        )
+
+    async def _arequest_stream_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> AsyncChatCompletionStreamManager[BaseModel]:
+        r"""Request async streaming structured output parsing.
+
+        Note: This uses OpenAI's beta streaming API for structured outputs.
+        """
+        import copy
+
+        request_config = copy.deepcopy(self.model_config_dict)
+
+        # Remove stream from config as it's handled by the stream method
+        request_config.pop("stream", None)
+
+        if tools is not None:
+            request_config["tools"] = tools
+
+        # Use the beta streaming API for structured outputs
+        return self._async_client.beta.chat.completions.stream(
+            messages=messages,
+            model=self.model_type,
+            response_format=response_format,
+            **request_config,
+        )
+
     @property
     def token_counter(self) -> BaseTokenCounter:
         r"""Initialize the token counter for the model backend.

camel/models/openai_model.py

@@ -16,6 +16,10 @@ import warnings
 from typing import Any, Dict, List, Optional, Type, Union
 
 from openai import AsyncOpenAI, AsyncStream, OpenAI, Stream
+from openai.lib.streaming.chat import (
+    AsyncChatCompletionStreamManager,
+    ChatCompletionStreamManager,
+)
 from pydantic import BaseModel
 
 from camel.configs import OPENAI_API_PARAMS, ChatGPTConfig
@@ -40,6 +44,11 @@ if os.environ.get("LANGFUSE_ENABLED", "False").lower() == "true":
         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
 
@@ -238,7 +247,11 @@ class OpenAIModel(BaseModelBackend):
         messages: List[OpenAIMessage],
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+    ) -> Union[
+        ChatCompletion,
+        Stream[ChatCompletionChunk],
+        ChatCompletionStreamManager[BaseModel],
+    ]:
         r"""Runs inference of OpenAI chat completion.
 
         Args:
@@ -250,9 +263,12 @@ class OpenAIModel(BaseModelBackend):
                 use for the request.
 
         Returns:
-            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
-                `ChatCompletion` in the non-stream mode, or
-                `Stream[ChatCompletionChunk]` in the stream mode.
+            Union[ChatCompletion, Stream[ChatCompletionChunk],
+                ChatCompletionStreamManager[BaseModel]]:
+                `ChatCompletion` in the non-stream mode,
+                `Stream[ChatCompletionChunk]`in the stream mode,
+                or `ChatCompletionStreamManager[BaseModel]` for
+                structured output streaming.
         """
 
         # Update Langfuse trace with current agent session and metadata
@@ -273,10 +289,22 @@ class OpenAIModel(BaseModelBackend):
         response_format = response_format or self.model_config_dict.get(
             "response_format", None
         )
+
+        # Check if streaming is enabled
+        is_streaming = self.model_config_dict.get("stream", False)
+
         if response_format:
             result: Union[ChatCompletion, Stream[ChatCompletionChunk]] = (
                 self._request_parse(messages, response_format, tools)
             )
+            if is_streaming:
+                # Use streaming parse for structured output
+                return self._request_stream_parse(
+                    messages, response_format, tools
+                )
+            else:
+                # Use non-streaming parse for structured output
+                return self._request_parse(messages, response_format, tools)
         else:
             result = self._request_chat_completion(messages, tools)
 
@@ -288,7 +316,11 @@ class OpenAIModel(BaseModelBackend):
         messages: List[OpenAIMessage],
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+    ) -> Union[
+        ChatCompletion,
+        AsyncStream[ChatCompletionChunk],
+        AsyncChatCompletionStreamManager[BaseModel],
+    ]:
         r"""Runs inference of OpenAI chat completion in async mode.
 
         Args:
@@ -300,9 +332,12 @@ class OpenAIModel(BaseModelBackend):
                 use for the request.
 
         Returns:
-            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
-                `ChatCompletion` in the non-stream mode, or
-                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk],
+                  AsyncChatCompletionStreamManager[BaseModel]]:
+                `ChatCompletion` in the non-stream mode,
+                `AsyncStream[ChatCompletionChunk]` in the stream mode, or
+                `AsyncChatCompletionStreamManager[BaseModel]` for
+                structured output streaming.
         """
 
         # Update Langfuse trace with current agent session and metadata
@@ -323,10 +358,24 @@ class OpenAIModel(BaseModelBackend):
         response_format = response_format or self.model_config_dict.get(
             "response_format", None
         )
+
+        # Check if streaming is enabled
+        is_streaming = self.model_config_dict.get("stream", False)
+
         if response_format:
             result: Union[
                 ChatCompletion, AsyncStream[ChatCompletionChunk]
             ] = await self._arequest_parse(messages, response_format, tools)
+            if is_streaming:
+                # Use streaming parse for structured output
+                return await self._arequest_stream_parse(
+                    messages, response_format, tools
+                )
+            else:
+                # Use non-streaming parse for structured output
+                return await self._arequest_parse(
+                    messages, response_format, tools
+                )
         else:
             result = await self._arequest_chat_completion(messages, tools)
 
@@ -422,6 +471,66 @@ class OpenAIModel(BaseModelBackend):
             **request_config,
         )
 
+    def _request_stream_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletionStreamManager[BaseModel]:
+        r"""Request streaming structured output parsing.
+
+        Note: This uses OpenAI's beta streaming API for structured outputs.
+        """
+        import copy
+
+        request_config = copy.deepcopy(self.model_config_dict)
+
+        # Remove stream from config as it's handled by the stream method
+        request_config.pop("stream", None)
+
+        if tools is not None:
+            request_config["tools"] = tools
+
+        request_config = self._sanitize_config(request_config)
+
+        # Use the beta streaming API for structured outputs
+        return self._client.beta.chat.completions.stream(
+            messages=messages,
+            model=self.model_type,
+            response_format=response_format,
+            **request_config,
+        )
+
+    async def _arequest_stream_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> AsyncChatCompletionStreamManager[BaseModel]:
+        r"""Request async streaming structured output parsing.
+
+        Note: This uses OpenAI's beta streaming API for structured outputs.
+        """
+        import copy
+
+        request_config = copy.deepcopy(self.model_config_dict)
+
+        # Remove stream from config as it's handled by the stream method
+        request_config.pop("stream", None)
+
+        if tools is not None:
+            request_config["tools"] = tools
+
+        request_config = self._sanitize_config(request_config)
+
+        # Use the beta streaming API for structured outputs
+        return self._async_client.beta.chat.completions.stream(
+            messages=messages,
+            model=self.model_type,
+            response_format=response_format,
+            **request_config,
+        )
+
     def check_model_config(self):
         r"""Check whether the model configuration contains any
         unexpected arguments to OpenAI API.

camel/societies/workforce/prompts.py

@@ -65,7 +65,8 @@ Example valid response:
   "assignments": [
     {{"task_id": "task_1", "assignee_id": "node_12345", "dependencies": []}},
     {{"task_id": "task_2", "assignee_id": "node_67890", "dependencies": ["task_1"]}},
-    {{"task_id": "task_3", "assignee_id": "node_12345", "dependencies": []}}
+    {{"task_id": "task_3", "assignee_id": "node_12345", "dependencies": []}},
+    {{"task_id": "task_4", "assignee_id": "node_67890", "dependencies": ["task_1", "task_2"]}}
   ]
 }}
 
@@ -96,6 +97,11 @@ Please keep in mind the task you are going to process, the content of the task t
 {content}
 ==============================
 
+Here is the content of the parent task for you to refer to:
+==============================
+{parent_task_content}
+==============================
+
 Here are results of some prerequisite tasks that you can refer to:
 
 ==============================
@@ -126,16 +132,22 @@ concluding remarks, explanations, or any other text outside the JSON structure i
 
 ROLEPLAY_PROCESS_TASK_PROMPT = TextPrompt(
     """You need to process the task. It is recommended that tools be actively called when needed.
-Here are results of some prerequisite tasks that you can refer to:
+
+The content of the task that you need to do is:
 
 ==============================
-{dependency_task_info}
+{content}
 ==============================
 
-The content of the task that you need to do is:
+Here is the content of the parent task for you to refer to:
+==============================
+{parent_task_content}
+==============================
+
+Here are results of some prerequisite tasks that you can refer to:
 
 ==============================
-{content}
+{dependency_task_info}
 ==============================
 
 Here are some additional information about the task:
@@ -254,3 +266,54 @@ Each subtask should be:
 - 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
 """
+
+FAILURE_ANALYSIS_PROMPT = TextPrompt(
+    """You need to analyze a task failure and decide on the best recovery strategy.
+
+**TASK FAILURE DETAILS:**
+Task ID: {task_id}
+Task Content: {task_content}
+Failure Count: {failure_count}/3
+Error Message: {error_message}
+Worker ID: {worker_id}
+Task Depth: {task_depth}
+Additional Info: {additional_info}
+
+**AVAILABLE RECOVERY STRATEGIES:**
+
+1. **RETRY**: Attempt the same task again without changes
+   - Use for: Network errors, temporary API issues, random failures
+   - Avoid for: Fundamental task misunderstanding, capability gaps
+
+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
+
+3. **DECOMPOSE**: Break the task into smaller, more manageable subtasks
+   - Use for: Complex tasks, capability mismatches, persistent failures
+   - Consider: Whether the task is too complex for a single worker
+
+4. **CREATE_WORKER**: Create a new worker node to handle the task
+   - Use for: Fundamental task misunderstanding, capability gaps
+
+**ANALYSIS GUIDELINES:**
+
+- **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
+- **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
+
+**RESPONSE FORMAT:**
+You must return a valid JSON object with these fields:
+- "strategy": one of "retry", "replan", or "decompose" 
+- "reasoning": explanation for your choice (1-2 sentences)
+- "modified_task_content": new task content if strategy is "replan", null otherwise
+
+**Example Response:**
+{{"strategy": "retry", "reasoning": "The connection error appears to be temporary and network-related, a simple retry should resolve this.", "modified_task_content": null}}
+
+**CRITICAL**: Return ONLY the JSON object. No explanations or text outside the JSON structure.
+"""
+)

camel/societies/workforce/role_playing_worker.py

@@ -104,6 +104,7 @@ class RolePlayingWorker(Worker):
         dependency_tasks_info = self._get_dep_tasks_info(dependencies)
         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,
             additional_info=task.additional_info,
         )

camel/societies/workforce/single_agent_worker.py

@@ -273,6 +273,7 @@ class SingleAgentWorker(Worker):
             dependency_tasks_info = self._get_dep_tasks_info(dependencies)
             prompt = PROCESS_TASK_PROMPT.format(
                 content=task.content,
+                parent_task_content=task.parent.content if task.parent else "",
                 dependency_tasks_info=dependency_tasks_info,
                 additional_info=task.additional_info,
             )

camel/societies/workforce/utils.py

@@ -11,10 +11,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from enum import Enum
 from functools import wraps
-from typing import Callable, List
+from typing import Callable, List, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 
 class WorkerConf(BaseModel):
@@ -54,6 +55,23 @@ class TaskAssignment(BaseModel):
         "This is critical for the task decomposition and execution.",
     )
 
+    # Allow LLMs to output dependencies as a comma-separated string or empty
+    # string. This validator converts such cases into a list[str] so that
+    # downstream logic does not break with validation errors.
+    @staticmethod
+    def _split_and_strip(dep_str: str) -> List[str]:
+        r"""Utility to split a comma separated string and strip whitespace."""
+        return [d.strip() for d in dep_str.split(',') if d.strip()]
+
+    @field_validator("dependencies", mode="before")
+    def validate_dependencies(cls, v) -> List[str]:
+        if v is None:
+            return []
+        # Handle empty string or comma-separated string from LLM
+        if isinstance(v, str):
+            return TaskAssignment._split_and_strip(v)
+        return v
+
 
 class TaskAssignResult(BaseModel):
     r"""The result of task assignment for both single and batch assignments."""
@@ -63,6 +81,53 @@ class TaskAssignResult(BaseModel):
     )
 
 
+class RecoveryStrategy(str, Enum):
+    r"""Strategies for handling failed tasks."""
+
+    RETRY = "retry"
+    REPLAN = "replan"
+    DECOMPOSE = "decompose"
+    CREATE_WORKER = "create_worker"
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return f"RecoveryStrategy.{self.name}"
+
+
+class FailureContext(BaseModel):
+    r"""Context information about a task failure."""
+
+    task_id: str = Field(description="ID of the failed task")
+    task_content: str = Field(description="Content of the failed task")
+    failure_count: int = Field(
+        description="Number of times this task has failed"
+    )
+    error_message: str = Field(description="Detailed error message")
+    worker_id: Optional[str] = Field(
+        default=None, description="ID of the worker that failed"
+    )
+    task_depth: int = Field(
+        description="Depth of the task in the decomposition hierarchy"
+    )
+    additional_info: Optional[str] = Field(
+        default=None, description="Additional context about the task"
+    )
+
+
+class RecoveryDecision(BaseModel):
+    r"""Decision on how to recover from a task failure."""
+
+    strategy: RecoveryStrategy = Field(
+        description="The chosen recovery strategy"
+    )
+    reasoning: str = Field(description="Explanation for the chosen strategy")
+    modified_task_content: Optional[str] = Field(
+        default=None, description="Modified task content if strategy is REPLAN"
+    )
+
+
 def check_if_running(
     running: bool,
     max_retries: int = 3,