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

camel/models/moonshot_model.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
+import copy
 import os
 from typing import Any, Dict, List, Optional, Type, Union
 
@@ -19,6 +20,7 @@ from openai import AsyncStream
 from pydantic import BaseModel
 
 from camel.configs import MoonshotConfig
+from camel.logger import get_logger
 from camel.messages import OpenAIMessage
 from camel.models._utils import try_modify_message_with_format
 from camel.models.openai_compatible_model import OpenAICompatibleModel
@@ -34,6 +36,8 @@ from camel.utils import (
     update_langfuse_trace,
 )
 
+logger = get_logger(__name__)
+
 if os.environ.get("LANGFUSE_ENABLED", "False").lower() == "true":
     try:
         from langfuse.decorators import observe
@@ -84,7 +88,7 @@ class MoonshotModel(OpenAICompatibleModel):
         model_type: Union[ModelType, str],
         model_config_dict: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
-        url: Optional[str] = "https://api.moonshot.ai/v1",
+        url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
         max_retries: int = 3,
@@ -93,7 +97,12 @@ class MoonshotModel(OpenAICompatibleModel):
         if model_config_dict is None:
             model_config_dict = MoonshotConfig().as_dict()
         api_key = api_key or os.environ.get("MOONSHOT_API_KEY")
-        url = url or os.environ.get("MOONSHOT_API_BASE_URL")
+        # Preserve default URL if not provided
+        if url is None:
+            url = (
+                os.environ.get("MOONSHOT_API_BASE_URL")
+                or "https://api.moonshot.ai/v1"
+            )
         timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
             model_type=model_type,
@@ -125,12 +134,12 @@ class MoonshotModel(OpenAICompatibleModel):
         Returns:
             Dict[str, Any]: The prepared request configuration.
         """
-        import copy
-
         request_config = copy.deepcopy(self.model_config_dict)
 
         if tools:
-            request_config["tools"] = tools
+            # Clean tools to remove null types (Moonshot API incompatibility)
+            cleaned_tools = self._clean_tool_schemas(tools)
+            request_config["tools"] = cleaned_tools
         elif response_format:
             # Use the same approach as DeepSeek for structured output
             try_modify_message_with_format(messages[-1], response_format)
@@ -138,6 +147,94 @@ class MoonshotModel(OpenAICompatibleModel):
 
         return request_config
 
+    def _clean_tool_schemas(
+        self, tools: List[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
+        r"""Clean tool schemas to remove null types for Moonshot compatibility.
+
+        Moonshot API doesn't accept {"type": "null"} in anyOf schemas.
+        This method removes null type definitions from parameters.
+
+        Args:
+            tools (List[Dict[str, Any]]): Original tool schemas.
+
+        Returns:
+            List[Dict[str, Any]]: Cleaned tool schemas.
+        """
+
+        def remove_null_from_schema(schema: Any) -> Any:
+            """Recursively remove null types from schema."""
+            if isinstance(schema, dict):
+                # Create a copy to avoid modifying the original
+                result = {}
+
+                for key, value in schema.items():
+                    if key == 'type' and isinstance(value, list):
+                        # Handle type arrays like ["string", "null"]
+                        filtered_types = [t for t in value if t != 'null']
+                        if len(filtered_types) == 1:
+                            # Single type remains, convert to string
+                            result[key] = filtered_types[0]
+                        elif len(filtered_types) > 1:
+                            # Multiple types remain, keep as array
+                            result[key] = filtered_types
+                        else:
+                            # All were null, use string as fallback
+                            logger.warning(
+                                "All types in tool schema type array "
+                                "were null, falling back to 'string' "
+                                "type for Moonshot API compatibility. "
+                                "Original tool schema may need review."
+                            )
+                            result[key] = 'string'
+                    elif key == 'anyOf':
+                        # Handle anyOf with null types
+                        filtered = [
+                            item
+                            for item in value
+                            if not (
+                                isinstance(item, dict)
+                                and item.get('type') == 'null'
+                            )
+                        ]
+                        if len(filtered) == 1:
+                            # If only one type remains, flatten it
+                            return remove_null_from_schema(filtered[0])
+                        elif len(filtered) > 1:
+                            result[key] = [
+                                remove_null_from_schema(item)
+                                for item in filtered
+                            ]
+                        else:
+                            # All were null, return string type as fallback
+                            logger.warning(
+                                "All types in tool schema anyOf were null, "
+                                "falling back to 'string' type for "
+                                "Moonshot API compatibility. Original "
+                                "tool schema may need review."
+                            )
+                            return {"type": "string"}
+                    else:
+                        # Recursively process other values
+                        result[key] = remove_null_from_schema(value)
+
+                return result
+            elif isinstance(schema, list):
+                return [remove_null_from_schema(item) for item in schema]
+            else:
+                return schema
+
+        cleaned_tools = copy.deepcopy(tools)
+        for tool in cleaned_tools:
+            if 'function' in tool and 'parameters' in tool['function']:
+                params = tool['function']['parameters']
+                if 'properties' in params:
+                    params['properties'] = remove_null_from_schema(
+                        params['properties']
+                    )
+
+        return cleaned_tools
+
     @observe()
     async def _arun(
         self,

camel/societies/workforce/events.py

@@ -0,0 +1,122 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class WorkforceEventBase(BaseModel):
+    model_config = ConfigDict(frozen=True, extra='forbid')
+    event_type: Literal[
+        "task_decomposed",
+        "task_created",
+        "task_assigned",
+        "task_started",
+        "task_completed",
+        "task_failed",
+        "worker_created",
+        "worker_deleted",
+        "queue_status",
+        "all_tasks_completed",
+    ]
+    metadata: Optional[Dict[str, Any]] = None
+    timestamp: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc)
+    )
+
+
+class WorkerCreatedEvent(WorkforceEventBase):
+    event_type: Literal["worker_created"] = "worker_created"
+    worker_id: str
+    worker_type: str
+    role: str
+
+
+class WorkerDeletedEvent(WorkforceEventBase):
+    event_type: Literal["worker_deleted"] = "worker_deleted"
+    worker_id: str
+    reason: Optional[str] = None
+
+
+class TaskDecomposedEvent(WorkforceEventBase):
+    event_type: Literal["task_decomposed"] = "task_decomposed"
+    parent_task_id: str
+    subtask_ids: List[str]
+
+
+class TaskCreatedEvent(WorkforceEventBase):
+    event_type: Literal["task_created"] = "task_created"
+    task_id: str
+    description: str
+    parent_task_id: Optional[str] = None
+    task_type: Optional[str] = None
+
+
+class TaskAssignedEvent(WorkforceEventBase):
+    event_type: Literal["task_assigned"] = "task_assigned"
+    task_id: str
+    worker_id: str
+    queue_time_seconds: Optional[float] = None
+    dependencies: Optional[List[str]] = None
+
+
+class TaskStartedEvent(WorkforceEventBase):
+    event_type: Literal["task_started"] = "task_started"
+    task_id: str
+    worker_id: str
+
+
+class TaskCompletedEvent(WorkforceEventBase):
+    event_type: Literal["task_completed"] = "task_completed"
+    task_id: str
+    worker_id: str
+    result_summary: Optional[str] = None
+    processing_time_seconds: Optional[float] = None
+    token_usage: Optional[Dict[str, int]] = None
+
+
+class TaskFailedEvent(WorkforceEventBase):
+    event_type: Literal["task_failed"] = "task_failed"
+    task_id: str
+    error_message: str
+    worker_id: Optional[str] = None
+
+
+class AllTasksCompletedEvent(WorkforceEventBase):
+    event_type: Literal["all_tasks_completed"] = "all_tasks_completed"
+
+
+class QueueStatusEvent(WorkforceEventBase):
+    event_type: Literal["queue_status"] = "queue_status"
+    queue_name: str
+    length: int
+    pending_task_ids: Optional[List[str]] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+WorkforceEvent = Union[
+    TaskDecomposedEvent,
+    TaskCreatedEvent,
+    TaskAssignedEvent,
+    TaskStartedEvent,
+    TaskCompletedEvent,
+    TaskFailedEvent,
+    WorkerCreatedEvent,
+    WorkerDeletedEvent,
+    AllTasksCompletedEvent,
+    QueueStatusEvent,
+]

camel/societies/workforce/single_agent_worker.py

@@ -80,6 +80,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 +106,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 +141,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 +152,7 @@ class AgentPool:
         if not self.auto_scale:
             return
 
-        async with self._lock:
+        async with self._condition:
             if not self._available_agents:
                 return
 
@@ -428,6 +426,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 +561,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 +581,14 @@ 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.
 
         Returns:
             Dict[str, Any]: Result dictionary with keys:
@@ -591,7 +596,19 @@ 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.
         """
+        import warnings
+
+        warnings.warn(
+            "save_workflow_memories() is synchronous. Consider using "
+            "save_workflow_memories_async() for async/await support.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         try:
             # validate requirements
             validation_error = self._validate_workflow_save_requirements()
@@ -603,13 +620,31 @@ class SingleAgentWorker(Worker):
             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
             )
 
+            # check if we should use role_name or let summarize extract
+            # task_title
+            role_name = getattr(self.worker, 'role_name', 'assistant')
+            use_role_name_for_filename = role_name.lower() not in {
+                'assistant',
+                'agent',
+                'user',
+                'system',
+            }
+
             # generate and save workflow summary
+            # if role_name is explicit, use it for filename
+            # if role_name is generic, pass none to let summarize use
+            # task_title
+            filename = (
+                self._generate_workflow_filename()
+                if use_role_name_for_filename
+                else None
+            )
+
             result = agent_to_summarize.summarize(
                 filename=filename,
                 summary_prompt=structured_prompt,
@@ -636,6 +671,84 @@ class SingleAgentWorker(Worker):
                 "message": f"Failed to save workflow memories: {e!s}",
             }
 
+    async def save_workflow_memories_async(self) -> Dict[str, Any]:
+        r"""Asynchronously save the worker's current workflow memories using
+        agent summarization.
+
+        This is the async version of save_workflow_memories() that uses
+        asummarize() for non-blocking LLM calls, enabling parallel
+        summarization of multiple workers.
+
+        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
+        """
+        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
+            structured_prompt = self._prepare_workflow_prompt()
+            agent_to_summarize = self._select_agent_for_summarization(
+                context_util
+            )
+
+            # check if we should use role_name or let summarize extract
+            # task_title
+            role_name = getattr(self.worker, 'role_name', 'assistant')
+            use_role_name_for_filename = role_name.lower() not in {
+                'assistant',
+                'agent',
+                'user',
+                'system',
+            }
+
+            # generate and save workflow summary
+            # if role_name is explicit, use it for filename
+            # if role_name is generic, pass none to let summarize use
+            # task_title
+            filename = (
+                self._generate_workflow_filename()
+                if use_role_name_for_filename
+                else None
+            )
+
+            # **KEY CHANGE**: Using asummarize() instead of summarize()
+            result = await agent_to_summarize.asummarize(
+                filename=filename,
+                summary_prompt=structured_prompt,
+                response_format=WorkflowSummary,
+            )
+
+            # 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
+
+        except Exception as e:
+            return {
+                "status": "error",
+                "summary": "",
+                "file_path": None,
+                "worker_description": self.description,
+                "message": f"Failed to save workflow memories: {e!s}",
+            }
+
     def load_workflow_memories(
         self,
         pattern: Optional[str] = None,
@@ -716,12 +829,23 @@ class SingleAgentWorker(Worker):
             )
             return []
 
-        # generate filename-safe search pattern from worker description
+        # generate filename-safe search pattern from worker role name
         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"
+            from camel.utils.context_utils import ContextUtility
+
+            # get role_name (always available, defaults to "assistant")
+            role_name = getattr(self.worker, 'role_name', 'assistant')
+            clean_name = ContextUtility.sanitize_workflow_filename(role_name)
+
+            # check if role_name is generic
+            generic_names = {'assistant', 'agent', 'user', 'system'}
+            if clean_name in generic_names:
+                # for generic role names, search for all workflow files
+                # since filename is based on task_title
+                pattern = "*_workflow*.md"
+            else:
+                # for explicit role names, search for role-specific files
+                pattern = f"{clean_name}_workflow*.md"
 
         # Get the base workforce_workflows directory
         camel_workdir = os.environ.get("CAMEL_WORKDIR")
@@ -816,15 +940,21 @@ class SingleAgentWorker(Worker):
         return None
 
     def _generate_workflow_filename(self) -> str:
-        r"""Generate a filename for the workflow based on worker description.
+        r"""Generate a filename for the workflow based on worker role name.
+
+        Uses the worker's explicit role_name when available.
 
         Returns:
-            str: Sanitized filename without timestamp (session already has
-                timestamp).
+            str: Sanitized filename without timestamp and without .md
+                extension. Format: {role_name}_workflow
         """
-        clean_desc = self.description.lower().replace(" ", "_")
-        clean_desc = re.sub(r'[^a-z0-9_]', '', clean_desc)
-        return f"{clean_desc}_workflow"
+        from camel.utils.context_utils import ContextUtility
+
+        # get role_name (always available, defaults to "assistant"/"Assistant")
+        role_name = getattr(self.worker, 'role_name', 'assistant')
+        clean_name = ContextUtility.sanitize_workflow_filename(role_name)
+
+        return f"{clean_name}_workflow"
 
     def _prepare_workflow_prompt(self) -> str:
         r"""Prepare the structured prompt for workflow summarization.