camel-ai 0.2.78__py3-none-any.whl → 0.2.79a1__py3-none-any.whl

camel/societies/workforce/single_agent_worker.py

@@ -15,12 +15,8 @@ from __future__ import annotations
 
 import asyncio
 import datetime
-import glob
-import os
-import re
 import time
 from collections import deque
-from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from colorama import Fore
@@ -34,8 +30,11 @@ from camel.societies.workforce.structured_output_handler import (
 )
 from camel.societies.workforce.utils import TaskResult
 from camel.societies.workforce.worker import Worker
+from camel.societies.workforce.workflow_memory_manager import (
+    WorkflowMemoryManager,
+)
 from camel.tasks.task import Task, TaskState, is_task_result_insufficient
-from camel.utils.context_utils import ContextUtility, WorkflowSummary
+from camel.utils.context_utils import ContextUtility
 
 logger = get_logger(__name__)
 
@@ -80,6 +79,7 @@ class AgentPool:
         self._in_use_agents: set = set()
         self._agent_last_used: dict = {}
         self._lock = asyncio.Lock()
+        self._condition = asyncio.Condition(self._lock)
 
         # Statistics
         self._total_borrows = 0
@@ -105,36 +105,31 @@ class AgentPool:
 
     async def get_agent(self) -> ChatAgent:
         r"""Get an agent from the pool, creating one if necessary."""
-        async with self._lock:
+        async with self._condition:
             self._total_borrows += 1
 
-            if self._available_agents:
-                agent = self._available_agents.popleft()
-                self._in_use_agents.add(id(agent))
-                self._pool_hits += 1
-                return agent
-
-            # Check if we can create a new agent
-            if len(self._in_use_agents) < self.max_size or self.auto_scale:
-                agent = self._create_fresh_agent()
-                self._in_use_agents.add(id(agent))
-                return agent
-
-        # Wait for available agent
-        while True:
-            async with self._lock:
+            # Try to get available agent or create new one
+            while True:
                 if self._available_agents:
                     agent = self._available_agents.popleft()
                     self._in_use_agents.add(id(agent))
                     self._pool_hits += 1
                     return agent
-            await asyncio.sleep(0.05)
+
+                # Check if we can create a new agent
+                if len(self._in_use_agents) < self.max_size or self.auto_scale:
+                    agent = self._create_fresh_agent()
+                    self._in_use_agents.add(id(agent))
+                    return agent
+
+                # Wait for an agent to be returned
+                await self._condition.wait()
 
     async def return_agent(self, agent: ChatAgent) -> None:
         r"""Return an agent to the pool."""
         agent_id = id(agent)
 
-        async with self._lock:
+        async with self._condition:
             if agent_id not in self._in_use_agents:
                 return
 
@@ -145,6 +140,8 @@ class AgentPool:
                 agent.reset()
                 self._agent_last_used[agent_id] = time.time()
                 self._available_agents.append(agent)
+                # Notify one waiting coroutine that an agent is available
+                self._condition.notify()
             else:
                 # Remove tracking for agents not returned to pool
                 self._agent_last_used.pop(agent_id, None)
@@ -154,7 +151,7 @@ class AgentPool:
         if not self.auto_scale:
             return
 
-        async with self._lock:
+        async with self._condition:
             if not self._available_agents:
                 return
 
@@ -256,6 +253,9 @@ class SingleAgentWorker(Worker):
         # from all task processing
         self._conversation_accumulator: Optional[ChatAgent] = None
 
+        # workflow memory manager for handling workflow operations
+        self._workflow_manager: Optional[WorkflowMemoryManager] = None
+
         # note: context utility is set on the worker agent during save/load
         # operations to avoid creating session folders during initialization
 
@@ -318,6 +318,21 @@ class SingleAgentWorker(Worker):
             )
         return self._conversation_accumulator
 
+    def _get_workflow_manager(self) -> WorkflowMemoryManager:
+        r"""Get or create the workflow memory manager."""
+        if self._workflow_manager is None:
+            context_util = (
+                self._shared_context_utility
+                if self._shared_context_utility is not None
+                else None
+            )
+            self._workflow_manager = WorkflowMemoryManager(
+                worker=self.worker,
+                description=self.description,
+                context_utility=context_util,
+            )
+        return self._workflow_manager
+
     async def _process_task(
         self, task: Task, dependencies: List[Task]
     ) -> TaskState:
@@ -344,11 +359,15 @@ class SingleAgentWorker(Worker):
 
         try:
             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,
+            prompt = str(
+                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,
+                )
             )
 
             if self.use_structured_output_handler and self.structured_handler:
@@ -428,6 +447,7 @@ class SingleAgentWorker(Worker):
                     "usage"
                 ) or final_response.info.get("token_usage")
             else:
+                final_response = response
                 usage_info = response.info.get("usage") or response.info.get(
                     "token_usage"
                 )
@@ -562,10 +582,11 @@ class SingleAgentWorker(Worker):
         while True:
             try:
                 # Fixed interval cleanup
-                await asyncio.sleep(self.agent_pool.cleanup_interval)
-
                 if self.agent_pool:
+                    await asyncio.sleep(self.agent_pool.cleanup_interval)
                     await self.agent_pool.cleanup_idle_agents()
+                else:
+                    break
             except asyncio.CancelledError:
                 break
             except Exception as e:
@@ -581,9 +602,16 @@ class SingleAgentWorker(Worker):
         r"""Save the worker's current workflow memories using agent
         summarization.
 
+        .. deprecated:: 0.2.80
+            Use :meth:`save_workflow_memories_async` for async/await support
+            and better integration with parallel workflow saving.
+
         This method generates a workflow summary from the worker agent's
         conversation history and saves it to a markdown file. The filename
-        is based on the worker's description for easy loading later.
+        is based on either the worker's explicit role_name or the generated
+        task_title from the summary.
+
+        Delegates to WorkflowMemoryManager for all workflow operations.
 
         Returns:
             Dict[str, Any]: Result dictionary with keys:
@@ -591,287 +619,111 @@ class SingleAgentWorker(Worker):
                 - summary (str): Generated workflow summary
                 - file_path (str): Path to saved file
                 - worker_description (str): Worker description used
+
+        See Also:
+            :meth:`save_workflow_memories_async`: Async version for better
+                performance in parallel workflows.
         """
-        try:
-            # validate requirements
-            validation_error = self._validate_workflow_save_requirements()
-            if validation_error:
-                return validation_error
-
-            # setup context utility and agent
-            context_util = self._get_context_utility()
-            self.worker.set_context_utility(context_util)
-
-            # prepare workflow summarization components
-            filename = self._generate_workflow_filename()
-            structured_prompt = self._prepare_workflow_prompt()
-            agent_to_summarize = self._select_agent_for_summarization(
-                context_util
-            )
+        import warnings
+
+        warnings.warn(
+            "save_workflow_memories() is synchronous. Consider using "
+            "save_workflow_memories_async() for async/await support.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        manager = self._get_workflow_manager()
+        result = manager.save_workflow(
+            conversation_accumulator=self._conversation_accumulator
+        )
 
-            # generate and save workflow summary
-            result = agent_to_summarize.summarize(
-                filename=filename,
-                summary_prompt=structured_prompt,
-                response_format=WorkflowSummary,
+        # clean up accumulator after successful save
+        if (
+            result.get("status") == "success"
+            and self._conversation_accumulator is not None
+        ):
+            logger.info(
+                "Cleaning up conversation accumulator after workflow "
+                "summarization"
             )
+            self._conversation_accumulator = None
 
-            # add worker metadata and cleanup
-            result["worker_description"] = self.description
-            if self._conversation_accumulator is not None:
-                logger.info(
-                    "Cleaning up conversation accumulator after workflow "
-                    "summarization"
-                )
-                self._conversation_accumulator = None
+        return result
 
-            return result
+    async def save_workflow_memories_async(self) -> Dict[str, Any]:
+        r"""Asynchronously save the worker's current workflow memories using
+        agent summarization.
 
-        except Exception as e:
-            return {
-                "status": "error",
-                "summary": "",
-                "file_path": None,
-                "worker_description": self.description,
-                "message": f"Failed to save workflow memories: {e!s}",
-            }
+        This is the async version of save_workflow_memories() that uses
+        asummarize() for non-blocking LLM calls, enabling parallel
+        summarization of multiple workers.
+
+        Delegates to WorkflowMemoryManager for all workflow operations.
+
+        Returns:
+            Dict[str, Any]: Result dictionary with keys:
+                - status (str): "success" or "error"
+                - summary (str): Generated workflow summary
+                - file_path (str): Path to saved file
+                - worker_description (str): Worker description used
+        """
+        manager = self._get_workflow_manager()
+        result = await manager.save_workflow_async(
+            conversation_accumulator=self._conversation_accumulator
+        )
+
+        # clean up accumulator after successful save
+        if (
+            result.get("status") == "success"
+            and self._conversation_accumulator is not None
+        ):
+            logger.info(
+                "Cleaning up conversation accumulator after workflow "
+                "summarization"
+            )
+            self._conversation_accumulator = None
+
+        return result
 
     def load_workflow_memories(
         self,
         pattern: Optional[str] = None,
-        max_files_to_load: int = 3,
+        max_workflows: int = 3,
         session_id: Optional[str] = None,
+        use_smart_selection: bool = True,
     ) -> bool:
-        r"""Load workflow memories matching worker description
-        from saved files.
+        r"""Load workflow memories using intelligent agent-based selection.
+
+        This method uses the worker agent to intelligently select the most
+        relevant workflows based on metadata (title, description, tags)
+        rather than simple filename pattern matching.
 
-        This method searches for workflow memory files that match the worker's
-        description and loads them into the agent's memory using
-        ContextUtility.
+        Delegates to WorkflowMemoryManager for all workflow operations.
 
         Args:
-            pattern (Optional[str]): Custom search pattern for workflow
-                memory files.
-                If None, uses worker description to generate pattern.
-            max_files_to_load (int): Maximum number of workflow files to load.
+            pattern (Optional[str]): Legacy parameter for backward
+                compatibility. When use_smart_selection=False, uses this
+                pattern for file matching. Ignored when smart selection
+                is enabled.
+            max_workflows (int): Maximum number of workflow files to load.
                 (default: :obj:`3`)
             session_id (Optional[str]): Specific workforce session ID to load
                 from. If None, searches across all sessions.
                 (default: :obj:`None`)
+            use_smart_selection (bool): Whether to use agent-based intelligent
+                workflow selection. When True, uses metadata and LLM to select
+                most relevant workflows. When False, falls back to pattern
+                matching. (default: :obj:`True`)
 
         Returns:
             bool: True if workflow memories were successfully loaded, False
                 otherwise.
         """
-        try:
-            # reset system message to original state before loading
-            # this prevents duplicate workflow context on multiple calls
-            if isinstance(self.worker, ChatAgent):
-                self.worker.reset_to_original_system_message()
-
-            # Find workflow memory files matching the pattern
-            workflow_files = self._find_workflow_files(pattern, session_id)
-            if not workflow_files:
-                return False
-
-            # Load the workflow memory files
-            loaded_count = self._load_workflow_files(
-                workflow_files, max_files_to_load
-            )
-
-            # Report results
-            logger.info(
-                f"Successfully loaded {loaded_count} workflow file(s) for "
-                f"{self.description}"
-            )
-            return loaded_count > 0
-
-        except Exception as e:
-            logger.warning(
-                f"Error loading workflow memories for {self.description}: "
-                f"{e!s}"
-            )
-            return False
-
-    def _find_workflow_files(
-        self, pattern: Optional[str], session_id: Optional[str] = None
-    ) -> List[str]:
-        r"""Find and return sorted workflow files matching the pattern.
-
-        Args:
-            pattern (Optional[str]): Custom search pattern for workflow files.
-                If None, uses worker description to generate pattern.
-            session_id (Optional[str]): Specific session ID to search in.
-                If None, searches across all sessions.
-
-        Returns:
-            List[str]: Sorted list of workflow file paths (empty if
-                validation fails).
-        """
-        # Ensure we have a ChatAgent worker
-        if not isinstance(self.worker, ChatAgent):
-            logger.warning(
-                f"Cannot load workflow: {self.description} worker is not "
-                "a ChatAgent"
-            )
-            return []
-
-        # generate filename-safe search pattern from worker description
-        if pattern is None:
-            # sanitize description: spaces to underscores, remove special chars
-            clean_desc = self.description.lower().replace(" ", "_")
-            clean_desc = re.sub(r'[^a-z0-9_]', '', clean_desc)
-            pattern = f"{clean_desc}_workflow*.md"
-
-        # Get the base workforce_workflows directory
-        camel_workdir = os.environ.get("CAMEL_WORKDIR")
-        if camel_workdir:
-            base_dir = os.path.join(camel_workdir, "workforce_workflows")
-        else:
-            base_dir = "workforce_workflows"
-
-        # search for workflow files in specified or all session directories
-        if session_id:
-            search_path = str(Path(base_dir) / session_id / pattern)
-        else:
-            # search across all session directories using wildcard pattern
-            search_path = str(Path(base_dir) / "*" / pattern)
-        workflow_files = glob.glob(search_path)
-
-        if not workflow_files:
-            logger.info(f"No workflow files found for pattern: {pattern}")
-            return []
-
-        # prioritize most recent sessions by session timestamp in
-        # directory name
-        def extract_session_timestamp(filepath: str) -> str:
-            match = re.search(r'session_(\d{8}_\d{6}_\d{6})', filepath)
-            return match.group(1) if match else ""
-
-        workflow_files.sort(key=extract_session_timestamp, reverse=True)
-        return workflow_files
-
-    def _load_workflow_files(
-        self, workflow_files: List[str], max_files_to_load: int
-    ) -> int:
-        r"""Load workflow files and return count of successful loads.
-
-        Args:
-            workflow_files (List[str]): List of workflow file paths to load.
-
-        Returns:
-            int: Number of successfully loaded workflow files.
-        """
-        loaded_count = 0
-        # limit loading to prevent context overflow
-        for file_path in workflow_files[:max_files_to_load]:
-            try:
-                # extract file and session info from full path
-                filename = os.path.basename(file_path).replace('.md', '')
-                session_dir = os.path.dirname(file_path)
-                session_id = os.path.basename(session_dir)
-
-                # create context utility for the specific session
-                # where file exists
-                temp_utility = ContextUtility.get_workforce_shared(session_id)
-
-                status = temp_utility.load_markdown_context_to_memory(
-                    self.worker, filename
-                )
-
-                if "Context appended" in status:
-                    loaded_count += 1
-                    logger.info(f"Loaded workflow: {filename}")
-                else:
-                    logger.warning(
-                        f"Failed to load workflow {filename}: {status}"
-                    )
-
-            except Exception as e:
-                logger.warning(
-                    f"Failed to load workflow file {file_path}: {e!s}"
-                )
-                continue
-
-        return loaded_count
-
-    def _validate_workflow_save_requirements(self) -> Optional[Dict[str, Any]]:
-        r"""Validate requirements for workflow saving.
-
-        Returns:
-            Optional[Dict[str, Any]]: Error result dict if validation fails,
-                None if validation passes.
-        """
-        if not isinstance(self.worker, ChatAgent):
-            return {
-                "status": "error",
-                "summary": "",
-                "file_path": None,
-                "worker_description": self.description,
-                "message": (
-                    "Worker must be a ChatAgent instance to save workflow "
-                    "memories"
-                ),
-            }
-        return None
-
-    def _generate_workflow_filename(self) -> str:
-        r"""Generate a filename for the workflow based on worker description.
-
-        Returns:
-            str: Sanitized filename without timestamp (session already has
-                timestamp).
-        """
-        clean_desc = self.description.lower().replace(" ", "_")
-        clean_desc = re.sub(r'[^a-z0-9_]', '', clean_desc)
-        return f"{clean_desc}_workflow"
-
-    def _prepare_workflow_prompt(self) -> str:
-        r"""Prepare the structured prompt for workflow summarization.
-
-        Returns:
-            str: Structured prompt for workflow summary.
-        """
-        workflow_prompt = WorkflowSummary.get_instruction_prompt()
-        return StructuredOutputHandler.generate_structured_prompt(
-            base_prompt=workflow_prompt, schema=WorkflowSummary
+        manager = self._get_workflow_manager()
+        return manager.load_workflows(
+            pattern=pattern,
+            max_files_to_load=max_workflows,
+            session_id=session_id,
+            use_smart_selection=use_smart_selection,
         )
-
-    def _select_agent_for_summarization(
-        self, context_util: ContextUtility
-    ) -> ChatAgent:
-        r"""Select the best agent for workflow summarization.
-
-        Args:
-            context_util: Context utility to set on selected agent.
-
-        Returns:
-            ChatAgent: Agent to use for summarization.
-        """
-        agent_to_summarize = self.worker
-
-        if self._conversation_accumulator is not None:
-            accumulator_messages, _ = (
-                self._conversation_accumulator.memory.get_context()
-            )
-            if accumulator_messages:
-                self._conversation_accumulator.set_context_utility(
-                    context_util
-                )
-                agent_to_summarize = self._conversation_accumulator
-                logger.info(
-                    f"Using conversation accumulator with "
-                    f"{len(accumulator_messages)} messages for workflow "
-                    f"summary"
-                )
-            else:
-                logger.info(
-                    "Using original worker for workflow summary (no "
-                    "accumulated conversations)"
-                )
-        else:
-            logger.info(
-                "Using original worker for workflow summary (no accumulator)"
-            )
-
-        return agent_to_summarize

camel/societies/workforce/utils.py

@@ -38,7 +38,8 @@ class TaskResult(BaseModel):
 
     content: str = Field(description="The result of the task.")
     failed: bool = Field(
-        description="Flag indicating whether the task processing failed."
+        default=False,
+        description="Flag indicating whether the task processing failed.",
     )