camel-ai 0.2.71a8__py3-none-any.whl → 0.2.71a9__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.71a8'
+__version__ = '0.2.71a9'
 
 __all__ = [
     '__version__',

camel/societies/workforce/single_agent_worker.py

@@ -22,6 +22,7 @@ from typing import Any, List, Optional
 from colorama import Fore
 
 from camel.agents import ChatAgent
+from camel.agents.chat_agent import AsyncStreamingChatAgentResponse
 from camel.societies.workforce.prompts import PROCESS_TASK_PROMPT
 from camel.societies.workforce.structured_output_handler import (
     StructuredOutputHandler,
@@ -285,6 +286,7 @@ class SingleAgentWorker(Worker):
         """
         # Get agent efficiently (from pool or by cloning)
         worker_agent = await self._get_worker_agent()
+        response_content = ""
 
         try:
             dependency_tasks_info = self._get_dep_tasks_info(dependencies)
@@ -314,11 +316,23 @@ class SingleAgentWorker(Worker):
                     )
                 )
                 response = await worker_agent.astep(enhanced_prompt)
+
+                # Handle streaming response
+                if isinstance(response, AsyncStreamingChatAgentResponse):
+                    content = ""
+                    async for chunk in response:
+                        if chunk.msg:
+                            content = chunk.msg.content
+                    response_content = content
+                else:
+                    # Regular ChatAgentResponse
+                    response_content = (
+                        response.msg.content if response.msg else ""
+                    )
+
                 task_result = (
                     self.structured_handler.parse_structured_response(
-                        response_text=response.msg.content
-                        if response.msg
-                        else "",
+                        response_text=response_content,
                         schema=TaskResult,
                         fallback_values={
                             "content": "Task processing failed",
@@ -331,13 +345,41 @@ class SingleAgentWorker(Worker):
                 response = await worker_agent.astep(
                     prompt, response_format=TaskResult
                 )
-                task_result = response.msg.parsed
+
+                # Handle streaming response for native output
+                if isinstance(response, AsyncStreamingChatAgentResponse):
+                    task_result = None
+                    async for chunk in response:
+                        if chunk.msg and chunk.msg.parsed:
+                            task_result = chunk.msg.parsed
+                            response_content = chunk.msg.content
+                    # If no parsed result found in streaming, create fallback
+                    if task_result is None:
+                        task_result = TaskResult(
+                            content="Failed to parse streaming response",
+                            failed=True,
+                        )
+                else:
+                    # Regular ChatAgentResponse
+                    task_result = response.msg.parsed
+                    response_content = (
+                        response.msg.content if response.msg else ""
+                    )
 
             # Get token usage from the response
-            usage_info = response.info.get("usage") or response.info.get(
-                "token_usage"
+            if isinstance(response, AsyncStreamingChatAgentResponse):
+                # For streaming responses, get the final response info
+                final_response = await response
+                usage_info = final_response.info.get(
+                    "usage"
+                ) or final_response.info.get("token_usage")
+            else:
+                usage_info = response.info.get("usage") or response.info.get(
+                    "token_usage"
+                )
+            total_tokens = (
+                usage_info.get("total_tokens", 0) if usage_info else 0
             )
-            total_tokens = usage_info.get("total_tokens", 0)
 
         except Exception as e:
             print(
@@ -369,8 +411,10 @@ class SingleAgentWorker(Worker):
             f"(from pool/clone of "
             f"{getattr(self.worker, 'agent_id', self.worker.role_name)}) "
             f"to process task {task.content}",
-            "response_content": response.msg.content,
-            "tool_calls": response.info.get("tool_calls"),
+            "response_content": response_content,
+            "tool_calls": final_response.info.get("tool_calls")
+            if isinstance(response, AsyncStreamingChatAgentResponse)
+            else response.info.get("tool_calls"),
             "total_tokens": total_tokens,
         }
 

camel/societies/workforce/workforce.py

@@ -25,6 +25,7 @@ from typing import (
     Coroutine,
     Deque,
     Dict,
+    Generator,
     List,
     Optional,
     Set,
@@ -420,6 +421,11 @@ class Workforce(BaseNode):
                 "CodeExecutionToolkit, and ThinkingToolkit. To customize "
                 "runtime worker creation, pass a ChatAgent instance."
             )
+        else:
+            # Validate new_worker_agent if provided
+            self._validate_agent_compatibility(
+                new_worker_agent, "new_worker_agent"
+            )
 
         if self.share_memory:
             logger.info(
@@ -432,6 +438,42 @@ class Workforce(BaseNode):
         # Helper for propagating pause control to externally supplied agents
         # ------------------------------------------------------------------
 
+    def _validate_agent_compatibility(
+        self, agent: ChatAgent, agent_context: str = "agent"
+    ) -> None:
+        r"""Validate that agent configuration is compatible with workforce
+        settings.
+
+        Args:
+            agent (ChatAgent): The agent to validate.
+            agent_context (str): Context description for error messages.
+
+        Raises:
+            ValueError: If agent has tools and stream mode enabled but
+                use_structured_output_handler is False.
+        """
+        agent_has_tools = (
+            bool(agent.tool_dict) if hasattr(agent, 'tool_dict') else False
+        )
+        agent_stream_mode = (
+            getattr(agent.model_backend, 'stream', False)
+            if hasattr(agent, 'model_backend')
+            else False
+        )
+
+        if (
+            agent_has_tools
+            and agent_stream_mode
+            and not self.use_structured_output_handler
+        ):
+            raise ValueError(
+                f"{agent_context} has tools and stream mode enabled, but "
+                "use_structured_output_handler is False. Native structured "
+                "output doesn't work with tool calls in stream mode. "
+                "Please set use_structured_output_handler=True when creating "
+                "the Workforce."
+            )
+
     def _attach_pause_event_to_agent(self, agent: ChatAgent) -> None:
         r"""Ensure the given ChatAgent shares this workforce's pause_event.
 
@@ -678,12 +720,15 @@ class Workforce(BaseNode):
         if task_id in self._assignees:
             del self._assignees[task_id]
 
-    def _decompose_task(self, task: Task) -> List[Task]:
+    def _decompose_task(
+        self, task: Task
+    ) -> Union[List[Task], Generator[List[Task], None, None]]:
         r"""Decompose the task into subtasks. This method will also set the
         relationship between the task and its subtasks.
 
         Returns:
-            List[Task]: The subtasks.
+            Union[List[Task], Generator[List[Task], None, None]]:
+            The subtasks or generator of subtasks.
         """
         decompose_prompt = WF_TASK_DECOMPOSE_PROMPT.format(
             content=task.content,
@@ -691,13 +736,30 @@ class Workforce(BaseNode):
             additional_info=task.additional_info,
         )
         self.task_agent.reset()
-        subtasks = task.decompose(self.task_agent, decompose_prompt)
-
-        # Update dependency tracking for decomposed task
-        if subtasks:
-            self._update_dependencies_for_decomposition(task, subtasks)
+        result = task.decompose(self.task_agent, decompose_prompt)
+
+        # Handle both streaming and non-streaming results
+        if isinstance(result, Generator):
+            # This is a generator (streaming mode)
+            def streaming_with_dependencies():
+                all_subtasks = []
+                for new_tasks in result:
+                    all_subtasks.extend(new_tasks)
+                    # Update dependency tracking for each batch of new tasks
+                    if new_tasks:
+                        self._update_dependencies_for_decomposition(
+                            task, all_subtasks
+                        )
+                    yield new_tasks
 
-        return subtasks
+            return streaming_with_dependencies()
+        else:
+            # This is a regular list (non-streaming mode)
+            subtasks = result
+            # Update dependency tracking for decomposed task
+            if subtasks:
+                self._update_dependencies_for_decomposition(task, subtasks)
+            return subtasks
 
     def _analyze_failure(
         self, task: Task, error_message: str
@@ -1148,7 +1210,17 @@ class Workforce(BaseNode):
         task.state = TaskState.FAILED
         # The agent tend to be overconfident on the whole task, so we
         # decompose the task into subtasks first
-        subtasks = self._decompose_task(task)
+        subtasks_result = self._decompose_task(task)
+
+        # Handle both streaming and non-streaming results
+        if isinstance(subtasks_result, Generator):
+            # This is a generator (streaming mode)
+            subtasks = []
+            for new_tasks in subtasks_result:
+                subtasks.extend(new_tasks)
+        else:
+            # This is a regular list (non-streaming mode)
+            subtasks = subtasks_result
         if self.metrics_logger and subtasks:
             self.metrics_logger.log_task_decomposed(
                 parent_task_id=task.id, subtask_ids=[st.id for st in subtasks]
@@ -1265,7 +1337,17 @@ class Workforce(BaseNode):
         task.state = TaskState.FAILED  # TODO: Add logic for OPEN
 
         # Decompose the task into subtasks first
-        subtasks = self._decompose_task(task)
+        subtasks_result = self._decompose_task(task)
+
+        # Handle both streaming and non-streaming results
+        if isinstance(subtasks_result, Generator):
+            # This is a generator (streaming mode)
+            subtasks = []
+            for new_tasks in subtasks_result:
+                subtasks.extend(new_tasks)
+        else:
+            # This is a regular list (non-streaming mode)
+            subtasks = subtasks_result
         if subtasks:
             # If decomposition happened, the original task becomes a container.
             # We only execute its subtasks.
@@ -1435,12 +1517,18 @@ class Workforce(BaseNode):
 
         Raises:
             RuntimeError: If called while workforce is running (not paused).
+            ValueError: If worker has tools and stream mode enabled but
+                use_structured_output_handler is False.
         """
         if self._state == WorkforceState.RUNNING:
             raise RuntimeError(
                 "Cannot add workers while workforce is running. "
                 "Pause the workforce first."
             )
+
+        # Validate worker agent compatibility
+        self._validate_agent_compatibility(worker, "Worker agent")
+
         # Ensure the worker agent shares this workforce's pause control
         self._attach_pause_event_to_agent(worker)
 
@@ -2084,6 +2172,14 @@ class Workforce(BaseNode):
             new_node_conf.sys_msg,
         )
 
+        # Validate the new agent compatibility before creating worker
+        try:
+            self._validate_agent_compatibility(
+                new_agent, f"Agent for task {task.id}"
+            )
+        except ValueError as e:
+            raise ValueError(f"Cannot create worker for task {task.id}: {e!s}")
+
         new_node = SingleAgentWorker(
             description=new_node_conf.description,
             worker=new_agent,
@@ -2349,7 +2445,17 @@ class Workforce(BaseNode):
 
             elif recovery_decision.strategy == RecoveryStrategy.DECOMPOSE:
                 # Decompose the task into subtasks
-                subtasks = self._decompose_task(task)
+                subtasks_result = self._decompose_task(task)
+
+                # Handle both streaming and non-streaming results
+                if isinstance(subtasks_result, Generator):
+                    # This is a generator (streaming mode)
+                    subtasks = []
+                    for new_tasks in subtasks_result:
+                        subtasks.extend(new_tasks)
+                else:
+                    # This is a regular list (non-streaming mode)
+                    subtasks = subtasks_result
                 if self.metrics_logger and subtasks:
                     self.metrics_logger.log_task_decomposed(
                         parent_task_id=task.id,
@@ -3203,6 +3309,18 @@ class Workforce(BaseNode):
                 )
 
                 agent = ChatAgent(sys_msg, **(agent_kwargs or {}))
+
+                # Validate agent compatibility
+                try:
+                    workforce_instance._validate_agent_compatibility(
+                        agent, "Worker agent"
+                    )
+                except ValueError as e:
+                    return {
+                        "status": "error",
+                        "message": str(e),
+                    }
+
                 workforce_instance.add_single_agent_worker(description, agent)
 
                 return {

camel/tasks/task.py

@@ -19,6 +19,7 @@ from typing import (
     Any,
     Callable,
     Dict,
+    Generator,
     List,
     Literal,
     Optional,
@@ -30,6 +31,7 @@ from pydantic import BaseModel, ConfigDict, Field
 
 if TYPE_CHECKING:
     from camel.agents import ChatAgent
+    from camel.agents.chat_agent import StreamingChatAgentResponse
 import uuid
 
 from camel.logger import get_logger
@@ -402,9 +404,9 @@ class Task(BaseModel):
         agent: "ChatAgent",
         prompt: Optional[str] = None,
         task_parser: Callable[[str, str], List["Task"]] = parse_response,
-    ) -> List["Task"]:
-        r"""Decompose a task to a list of sub-tasks. It can be used for data
-        generation and planner of agent.
+    ) -> Union[List["Task"], Generator[List["Task"], None, None]]:
+        r"""Decompose a task to a list of sub-tasks. Automatically detects
+        streaming or non-streaming based on agent configuration.
 
         Args:
             agent (ChatAgent): An agent that used to decompose the task.
@@ -415,7 +417,10 @@ class Task(BaseModel):
                 the default parse_response will be used.
 
         Returns:
-            List[Task]: A list of tasks which are :obj:`Task` instances.
+            Union[List[Task], Generator[List[Task], None, None]]: If agent is
+                configured for streaming, returns a generator that yields lists
+                of new tasks as they are parsed. Otherwise returns a list of
+                all tasks.
         """
 
         role_name = agent.role_name
@@ -427,6 +432,72 @@ class Task(BaseModel):
             role_name=role_name, content=content
         )
         response = agent.step(msg)
+
+        # Auto-detect streaming based on response type
+        from camel.agents.chat_agent import StreamingChatAgentResponse
+
+        if isinstance(response, StreamingChatAgentResponse):
+            return self._decompose_streaming(response, task_parser)
+        else:
+            return self._decompose_non_streaming(response, task_parser)
+
+    def _decompose_streaming(
+        self,
+        response: "StreamingChatAgentResponse",
+        task_parser: Callable[[str, str], List["Task"]],
+    ) -> Generator[List["Task"], None, None]:
+        r"""Handle streaming response for task decomposition.
+
+        Args:
+            response: Streaming response from agent
+            task_parser: Function to parse tasks from response
+
+        Yields:
+            List[Task]: New tasks as they are parsed from streaming response
+        """
+        accumulated_content = ""
+        yielded_count = 0
+
+        # Process streaming response
+        for chunk in response:
+            accumulated_content = chunk.msg.content
+
+            # Try to parse partial tasks from accumulated content
+            try:
+                current_tasks = self._parse_partial_tasks(accumulated_content)
+
+                # Yield new tasks if we have more than previously yielded
+                if len(current_tasks) > yielded_count:
+                    new_tasks = current_tasks[yielded_count:]
+                    for task in new_tasks:
+                        task.additional_info = self.additional_info
+                        task.parent = self
+                    yield new_tasks
+                    yielded_count = len(current_tasks)
+
+            except Exception:
+                # If parsing fails, continue accumulating
+                continue
+
+        # Final complete parsing
+        final_tasks = task_parser(accumulated_content, self.id)
+        for task in final_tasks:
+            task.additional_info = self.additional_info
+            task.parent = self
+        self.subtasks = final_tasks
+
+    def _decompose_non_streaming(
+        self, response, task_parser: Callable[[str, str], List["Task"]]
+    ) -> List["Task"]:
+        r"""Handle non-streaming response for task decomposition.
+
+        Args:
+            response: Regular response from agent
+            task_parser: Function to parse tasks from response
+
+        Returns:
+            List[Task]: All parsed tasks
+        """
         tasks = task_parser(response.msg.content, self.id)
         for task in tasks:
             task.additional_info = self.additional_info
@@ -434,6 +505,35 @@ class Task(BaseModel):
         self.subtasks = tasks
         return tasks
 
+    def _parse_partial_tasks(self, response: str) -> List["Task"]:
+        r"""Parse tasks from potentially incomplete response.
+
+        Args:
+            response: Partial response content
+
+        Returns:
+            List[Task]: Tasks parsed from complete <task></task> blocks
+        """
+        pattern = r"<task>(.*?)</task>"
+        tasks_content = re.findall(pattern, response, re.DOTALL)
+
+        tasks = []
+        task_id = self.id or "0"
+
+        for i, content in enumerate(tasks_content, 1):
+            stripped_content = content.strip()
+            if validate_task_content(stripped_content, f"{task_id}.{i}"):
+                tasks.append(
+                    Task(content=stripped_content, id=f"{task_id}.{i}")
+                )
+            else:
+                logger.warning(
+                    f"Skipping invalid subtask {task_id}.{i} "
+                    f"during streaming decomposition: "
+                    f"Content '{stripped_content[:50]}...' failed validation"
+                )
+        return tasks
+
     def compose(
         self,
         agent: "ChatAgent",

{camel_ai-0.2.71a8.dist-info → camel_ai-0.2.71a9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.71a8
+Version: 0.2.71a9
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel

{camel_ai-0.2.71a8.dist-info → camel_ai-0.2.71a9.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=TUs23EA2p98OC0WV8dpKGkATsBnuXjPHnsVhnXlDUPk,901
+camel/__init__.py,sha256=5n7NZMAxb749oqgkyLbTX4gLlHYBd4c8HTvC0fzotXg,901
 camel/generators.py,sha256=JRqj9_m1PF4qT6UtybzTQ-KBT9MJQt18OAAYvQ_fr2o,13844
 camel/human.py,sha256=Xg8x1cS5KK4bQ1SDByiHZnzsRpvRP-KZViNvmu38xo4,5475
 camel/logger.py,sha256=WgEwael_eT6D-lVAKHpKIpwXSTjvLbny5jbV1Ab8lnA,5760
@@ -275,12 +275,12 @@ camel/societies/workforce/__init__.py,sha256=bkTI-PE-MSK9AQ2V2gR6cR2WY-R7Jqy_NmX
 camel/societies/workforce/base.py,sha256=z2DmbTP5LL5-aCAAqglznQqCLfPmnyM5zD3w6jjtsb8,2175
 camel/societies/workforce/prompts.py,sha256=gobVelz7rRdReogFG2QCfFy21GfhaQJyoiNnKWo4EHE,14391
 camel/societies/workforce/role_playing_worker.py,sha256=z5-OcNiaNEaoC206_3HD7xeonuUkD-XTxYbD3AqoNC8,10319
-camel/societies/workforce/single_agent_worker.py,sha256=seWeFR-scpaTSS0yXwqJSJkUWaNuiYyuxDTfbpebRN8,17314
+camel/societies/workforce/single_agent_worker.py,sha256=fXgAEkDMhvTd-nbwy5Gw3BOaRAiPsL8mf3AW1aaNqKU,19342
 camel/societies/workforce/structured_output_handler.py,sha256=xr8szFN86hg3jQ825aEkJTjkSFQnTlbinVg4j1vZJVI,17870
 camel/societies/workforce/task_channel.py,sha256=GWHaGQBpjTzdKbWoBYAQzzAiLKRKRXa6beqtc4cg-Is,7611
 camel/societies/workforce/utils.py,sha256=THgNHSeZsNVnjTzQTur3qCJhi72MrDS8X2gPET174cI,8434
 camel/societies/workforce/worker.py,sha256=k_AokiF-HAfq6Cd5SQYb0uaoJsA_kSwV_n5o1fxvzmo,6522
-camel/societies/workforce/workforce.py,sha256=u-AVADZFYWLQMB6WjB8gsDcVE3z48LYpGDwdkhlIut0,133692
+camel/societies/workforce/workforce.py,sha256=HD9Q5U4hqtTYewNWbYxa7u6ojW6lyGX_o_K7alm4S6E,138306
 camel/societies/workforce/workforce_logger.py,sha256=0YT__ys48Bgn0IICKIZBmSWhON-eA1KShebjCdn5ppE,24525
 camel/storages/__init__.py,sha256=RwpEyvxpMbJzVDZJJygeBg4AzyYMkTjjkfB53hTuqGo,2141
 camel/storages/graph_storages/__init__.py,sha256=G29BNn651C0WTOpjCl4QnVM-4B9tcNh8DdmsCiONH8Y,948
@@ -310,7 +310,7 @@ camel/storages/vectordb_storages/qdrant.py,sha256=a_cT0buSCHQ2CPZy852-mdvMDwy5zo
 camel/storages/vectordb_storages/tidb.py,sha256=w83bxgKgso43MtHqlpf2EMSpn1_Nz6ZZtY4fPw_-vgs,11192
 camel/storages/vectordb_storages/weaviate.py,sha256=wDUE4KvfmOl3DqHFU4uF0VKbHu-q9vKhZDe8FZ6QXsk,27888
 camel/tasks/__init__.py,sha256=MuHwkw5GRQc8NOCzj8tjtBrr2Xg9KrcKp-ed_-2ZGIM,906
-camel/tasks/task.py,sha256=-TqoSIrWk_BaocNUqr3RVowA9JBe2OO_fAXTdp6nXAU,20366
+camel/tasks/task.py,sha256=GNkySKVtX8h6kCgSA9AIT5OQNlt4v87oxyNiYWmHebE,24118
 camel/tasks/task_prompt.py,sha256=3KZmKYKUPcTKe8EAZOZBN3G05JHRVt7oHY9ORzLVu1g,2150
 camel/terminators/__init__.py,sha256=t8uqrkUnXEOYMXQDgaBkMFJ0EXFKI0kmx4cUimli3Ls,991
 camel/terminators/base.py,sha256=xmJzERX7GdSXcxZjAHHODa0rOxRChMSRboDCNHWSscs,1511
@@ -446,7 +446,7 @@ camel/verifiers/math_verifier.py,sha256=tA1D4S0sm8nsWISevxSN0hvSVtIUpqmJhzqfbuMo
 camel/verifiers/models.py,sha256=GdxYPr7UxNrR1577yW4kyroRcLGfd-H1GXgv8potDWU,2471
 camel/verifiers/physics_verifier.py,sha256=c1grrRddcrVN7szkxhv2QirwY9viIRSITWeWFF5HmLs,30187
 camel/verifiers/python_verifier.py,sha256=ogTz77wODfEcDN4tMVtiSkRQyoiZbHPY2fKybn59lHw,20558
-camel_ai-0.2.71a8.dist-info/METADATA,sha256=v1GZ0ttSR8kcp2jXjYxmz0SUh6EOf_eaR7QdoTP8BcY,50002
-camel_ai-0.2.71a8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-camel_ai-0.2.71a8.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.71a8.dist-info/RECORD,,
+camel_ai-0.2.71a9.dist-info/METADATA,sha256=3IG3o0Zfp79IqN8Y6I6N5jJsjw0-A9A_gqwDszF8qLw,50002
+camel_ai-0.2.71a9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+camel_ai-0.2.71a9.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.71a9.dist-info/RECORD,,