camel-ai 0.2.71a4__py3-none-any.whl → 0.2.71a6__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

@@ -13,7 +13,6 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-import json
 from typing import Dict, List, Optional
 
 from colorama import Fore
@@ -25,6 +24,9 @@ from camel.societies.workforce.prompts import (
     ROLEPLAY_PROCESS_TASK_PROMPT,
     ROLEPLAY_SUMMARIZE_PROMPT,
 )
+from camel.societies.workforce.structured_output_handler import (
+    StructuredOutputHandler,
+)
 from camel.societies.workforce.utils import TaskResult
 from camel.societies.workforce.worker import Worker
 from camel.tasks.task import Task, TaskState, is_task_result_insufficient
@@ -48,6 +50,14 @@ class RolePlayingWorker(Worker):
             (default: :obj:`None`)
         chat_turn_limit (int): The maximum number of chat turns in the role
             playing. (default: :obj:`20`)
+        use_structured_output_handler (bool, optional): Whether to use the
+            structured output handler instead of native structured output.
+            When enabled, the workforce will use prompts with structured
+            output instructions and regex extraction to parse responses.
+            This ensures compatibility with agents that don't reliably
+            support native structured output. When disabled, the workforce
+            uses the native response_format parameter.
+            (default: :obj:`True`)
     """
 
     def __init__(
@@ -59,8 +69,15 @@ class RolePlayingWorker(Worker):
         user_agent_kwargs: Optional[Dict] = None,
         summarize_agent_kwargs: Optional[Dict] = None,
         chat_turn_limit: int = 20,
+        use_structured_output_handler: bool = True,
     ) -> None:
         super().__init__(description)
+        self.use_structured_output_handler = use_structured_output_handler
+        self.structured_handler = (
+            StructuredOutputHandler()
+            if use_structured_output_handler
+            else None
+        )
         self.summarize_agent_kwargs = summarize_agent_kwargs
         summ_sys_msg = BaseMessage.make_assistant_message(
             role_name="Summarizer",
@@ -104,6 +121,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,
         )
@@ -172,13 +190,53 @@ class RolePlayingWorker(Worker):
             chat_history=chat_history_str,
             additional_info=task.additional_info,
         )
-        response = self.summarize_agent.step(
-            prompt, response_format=TaskResult
-        )
-        result_dict = json.loads(response.msg.content)
-        task_result = TaskResult(**result_dict)
+        if self.use_structured_output_handler and self.structured_handler:
+            # Use structured output handler for prompt-based extraction
+            enhanced_prompt = (
+                self.structured_handler.generate_structured_prompt(
+                    base_prompt=prompt,
+                    schema=TaskResult,
+                    examples=[
+                        {
+                            "content": "The assistant successfully completed "
+                            "the task by...",
+                            "failed": False,
+                        }
+                    ],
+                    additional_instructions=(
+                        "Summarize the task execution based "
+                        "on the chat history, clearly indicating whether "
+                        "the task succeeded or failed."
+                    ),
+                )
+            )
+            response = self.summarize_agent.step(enhanced_prompt)
+            task_result = self.structured_handler.parse_structured_response(
+                response_text=response.msg.content if response.msg else "",
+                schema=TaskResult,
+                fallback_values={
+                    "content": "Task summarization failed",
+                    "failed": True,
+                },
+            )
+        else:
+            # Use native structured output if supported
+            response = self.summarize_agent.step(
+                prompt, response_format=TaskResult
+            )
+            if response.msg.parsed is None:
+                print(
+                    f"{Fore.RED}Error in summarization: Invalid "
+                    f"task result{Fore.RESET}"
+                )
+                task_result = TaskResult(
+                    content="Failed to generate valid task summary.",
+                    failed=True,
+                )
+            else:
+                task_result = response.msg.parsed
 
-        task.result = task_result.content
+        task.result = task_result.content  # type: ignore[union-attr]
 
         if is_task_result_insufficient(task):
             print(