camel-ai 0.2.71a5__py3-none-any.whl → 0.2.71a7__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.71a5'
+__version__ = '0.2.71a7'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -3815,7 +3815,7 @@ class ChatAgent(BaseAgent):
                 self.memory.get_context_creator(), "token_limit", None
             ),
             output_language=self._output_language,
-            tools=[tool.func for tool in self._internal_tools.values()],
+            tools=self._clone_tools(),
             external_tools=[
                 schema for schema in self._external_tool_schemas.values()
             ],
@@ -3839,6 +3839,56 @@ class ChatAgent(BaseAgent):
 
         return new_agent
 
+    def _clone_tools(self) -> List[Union[FunctionTool, Callable]]:
+        r"""Clone tools for new agent instance,
+        handling stateful toolkits properly."""
+        cloned_tools = []
+        hybrid_browser_toolkits = {}  # Cache for created toolkits
+
+        for tool in self._internal_tools.values():
+            # Check if this is a HybridBrowserToolkit method
+            if (
+                hasattr(tool.func, '__self__')
+                and tool.func.__self__.__class__.__name__
+                == 'HybridBrowserToolkit'
+            ):
+                toolkit_instance = tool.func.__self__
+                toolkit_id = id(toolkit_instance)
+
+                # Check if we already created a clone for this toolkit
+                if toolkit_id not in hybrid_browser_toolkits:
+                    try:
+                        import uuid
+
+                        new_session_id = str(uuid.uuid4())[:8]
+                        new_toolkit = toolkit_instance.clone_for_new_session(
+                            new_session_id
+                        )
+                        hybrid_browser_toolkits[toolkit_id] = new_toolkit
+                    except Exception as e:
+                        logger.warning(
+                            f"Failed to clone HybridBrowserToolkit: {e}"
+                        )
+                        # Fallback to original function
+                        cloned_tools.append(tool.func)
+                        continue
+
+                # Get the corresponding method from the cloned toolkit
+                new_toolkit = hybrid_browser_toolkits[toolkit_id]
+                method_name = tool.func.__name__
+                if hasattr(new_toolkit, method_name):
+                    new_method = getattr(new_toolkit, method_name)
+                    cloned_tools.append(new_method)
+                else:
+                    # Fallback to original function
+                    cloned_tools.append(tool.func)
+            else:
+                # Regular tool or other stateless toolkit
+                # just use the original function
+                cloned_tools.append(tool.func)
+
+        return cloned_tools
+
     def __repr__(self) -> str:
         r"""Returns a string representation of the :obj:`ChatAgent`.
 

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",
@@ -173,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(

camel/societies/workforce/single_agent_worker.py

@@ -15,7 +15,6 @@ from __future__ import annotations
 
 import asyncio
 import datetime
-import json
 import time
 from collections import deque
 from typing import Any, List, Optional
@@ -24,6 +23,9 @@ from colorama import Fore
 
 from camel.agents import ChatAgent
 from camel.societies.workforce.prompts import PROCESS_TASK_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
@@ -186,6 +188,14 @@ class SingleAgentWorker(Worker):
             (default: :obj:`10`)
         auto_scale_pool (bool): Whether to auto-scale the agent pool.
             (default: :obj:`True`)
+        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__(
@@ -196,12 +206,19 @@ class SingleAgentWorker(Worker):
         pool_initial_size: int = 1,
         pool_max_size: int = 10,
         auto_scale_pool: bool = True,
+        use_structured_output_handler: bool = True,
     ) -> None:
         node_id = worker.agent_id
         super().__init__(
             description,
             node_id=node_id,
         )
+        self.use_structured_output_handler = use_structured_output_handler
+        self.structured_handler = (
+            StructuredOutputHandler()
+            if use_structured_output_handler
+            else None
+        )
         self.worker = worker
         self.use_agent_pool = use_agent_pool
 
@@ -278,9 +295,43 @@ class SingleAgentWorker(Worker):
                 additional_info=task.additional_info,
             )
 
-            response = await worker_agent.astep(
-                prompt, response_format=TaskResult
-            )
+            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": "I have successfully completed the "
+                                "task...",
+                                "failed": False,
+                            }
+                        ],
+                        additional_instructions="Ensure you provide a clear "
+                        "description of what was done and whether the task "
+                        "succeeded or failed.",
+                    )
+                )
+                response = await worker_agent.astep(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 processing failed",
+                            "failed": True,
+                        },
+                    )
+                )
+            else:
+                # Use native structured output if supported
+                response = await worker_agent.astep(
+                    prompt, response_format=TaskResult
+                )
+                task_result = response.msg.parsed
 
             # Get token usage from the response
             usage_info = response.info.get("usage") or response.info.get(
@@ -293,6 +344,8 @@ class SingleAgentWorker(Worker):
                 f"{Fore.RED}Error processing task {task.id}: "
                 f"{type(e).__name__}: {e}{Fore.RESET}"
             )
+            # Store error information in task result
+            task.result = f"{type(e).__name__}: {e!s}"
             return TaskState.FAILED
         finally:
             # Return agent to pool or let it be garbage collected
@@ -331,25 +384,27 @@ class SingleAgentWorker(Worker):
 
         print(f"======\n{Fore.GREEN}Response from {self}:{Fore.RESET}")
 
-        try:
-            result_dict = json.loads(response.msg.content)
-            task_result = TaskResult(**result_dict)
-        except json.JSONDecodeError as e:
-            print(
-                f"{Fore.RED}JSON parsing error for task {task.id}: "
-                f"Invalid response format - {e}{Fore.RESET}"
-            )
-            return TaskState.FAILED
-
-        color = Fore.RED if task_result.failed else Fore.GREEN
+        if not self.use_structured_output_handler:
+            # Handle native structured output parsing
+            if task_result is None:
+                print(
+                    f"{Fore.RED}Error in worker step execution: Invalid "
+                    f"task result{Fore.RESET}"
+                )
+                task_result = TaskResult(
+                    content="Failed to generate valid task result.",
+                    failed=True,
+                )
+
+        color = Fore.RED if task_result.failed else Fore.GREEN  # type: ignore[union-attr]
         print(
-            f"\n{color}{task_result.content}{Fore.RESET}\n======",
+            f"\n{color}{task_result.content}{Fore.RESET}\n======",  # type: ignore[union-attr]
         )
 
-        if task_result.failed:
+        if task_result.failed:  # type: ignore[union-attr]
             return TaskState.FAILED
 
-        task.result = task_result.content
+        task.result = task_result.content  # type: ignore[union-attr]
 
         if is_task_result_insufficient(task):
             print(