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

camel/societies/workforce/workforce_callback.py

@@ -0,0 +1,74 @@
+# ========= 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 abc import ABC, abstractmethod
+
+from .events import (
+    AllTasksCompletedEvent,
+    TaskAssignedEvent,
+    TaskCompletedEvent,
+    TaskCreatedEvent,
+    TaskDecomposedEvent,
+    TaskFailedEvent,
+    TaskStartedEvent,
+    WorkerCreatedEvent,
+    WorkerDeletedEvent,
+)
+
+
+class WorkforceCallback(ABC):
+    r"""Interface for recording workforce lifecycle events.
+
+    Implementations should persist or stream events as appropriate.
+    """
+
+    @abstractmethod
+    def log_task_created(
+        self,
+        event: TaskCreatedEvent,
+    ) -> None:
+        pass
+
+    @abstractmethod
+    def log_task_decomposed(self, event: TaskDecomposedEvent) -> None:
+        pass
+
+    @abstractmethod
+    def log_task_assigned(self, event: TaskAssignedEvent) -> None:
+        pass
+
+    @abstractmethod
+    def log_task_started(self, event: TaskStartedEvent) -> None:
+        pass
+
+    @abstractmethod
+    def log_task_completed(self, event: TaskCompletedEvent) -> None:
+        pass
+
+    @abstractmethod
+    def log_task_failed(self, event: TaskFailedEvent) -> None:
+        pass
+
+    @abstractmethod
+    def log_worker_created(self, event: WorkerCreatedEvent) -> None:
+        pass
+
+    @abstractmethod
+    def log_worker_deleted(self, event: WorkerDeletedEvent) -> None:
+        pass
+
+    @abstractmethod
+    def log_all_tasks_completed(self, event: AllTasksCompletedEvent) -> None:
+        pass

camel/societies/workforce/workforce_logger.py

@@ -16,12 +16,26 @@ from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
 from camel.logger import get_logger
+from camel.societies.workforce.events import (
+    AllTasksCompletedEvent,
+    QueueStatusEvent,
+    TaskAssignedEvent,
+    TaskCompletedEvent,
+    TaskCreatedEvent,
+    TaskDecomposedEvent,
+    TaskFailedEvent,
+    TaskStartedEvent,
+    WorkerCreatedEvent,
+    WorkerDeletedEvent,
+)
+from camel.societies.workforce.workforce_callback import WorkforceCallback
+from camel.societies.workforce.workforce_metrics import WorkforceMetrics
 from camel.types.agents import ToolCallingRecord
 
 logger = get_logger(__name__)
 
 
-class WorkforceLogger:
+class WorkforceLogger(WorkforceCallback, WorkforceMetrics):
     r"""Logs events and metrics for a Workforce instance."""
 
     def __init__(self, workforce_id: str):
@@ -55,195 +69,201 @@ class WorkforceLogger:
 
     def log_task_created(
         self,
-        task_id: str,
-        description: str,
-        parent_task_id: Optional[str] = None,
-        task_type: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        event: TaskCreatedEvent,
     ) -> None:
         r"""Logs the creation of a new task."""
         self._log_event(
-            'task_created',
-            task_id=task_id,
-            description=description,
-            parent_task_id=parent_task_id,
-            task_type=task_type,
-            metadata=metadata or {},
+            event_type=event.event_type,
+            task_id=event.task_id,
+            description=event.description,
+            parent_task_id=event.parent_task_id,
+            task_type=event.task_type,
+            metadata=event.metadata or {},
         )
-        self._task_hierarchy[task_id] = {
-            'parent': parent_task_id,
+        self._task_hierarchy[event.task_id] = {
+            'parent': event.parent_task_id,
             'children': [],
             'status': 'created',
-            'description': description,
+            'description': event.description,
             'assigned_to': None,
-            **(metadata or {}),
+            **(event.metadata or {}),
         }
-        if parent_task_id and parent_task_id in self._task_hierarchy:
-            self._task_hierarchy[parent_task_id]['children'].append(task_id)
+        if (
+            event.parent_task_id
+            and event.parent_task_id in self._task_hierarchy
+        ):
+            self._task_hierarchy[event.parent_task_id]['children'].append(
+                event.task_id
+            )
 
     def log_task_decomposed(
         self,
-        parent_task_id: str,
-        subtask_ids: List[str],
-        metadata: Optional[Dict[str, Any]] = None,
+        event: TaskDecomposedEvent,
     ) -> None:
         r"""Logs the decomposition of a task into subtasks."""
         self._log_event(
-            'task_decomposed',
-            parent_task_id=parent_task_id,
-            subtask_ids=subtask_ids,
-            metadata=metadata or {},
+            event_type=event.event_type,
+            parent_task_id=event.parent_task_id,
+            subtask_ids=event.subtask_ids,
+            metadata=event.metadata or {},
         )
-        if parent_task_id in self._task_hierarchy:
-            self._task_hierarchy[parent_task_id]['status'] = "decomposed"
+        if event.parent_task_id in self._task_hierarchy:
+            self._task_hierarchy[event.parent_task_id]['status'] = "decomposed"
 
     def log_task_assigned(
         self,
-        task_id: str,
-        worker_id: str,
-        queue_time_seconds: Optional[float] = None,
-        dependencies: Optional[List[str]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        event: TaskAssignedEvent,
     ) -> None:
         r"""Logs the assignment of a task to a worker."""
         self._log_event(
-            'task_assigned',
-            task_id=task_id,
-            worker_id=worker_id,
-            queue_time_seconds=queue_time_seconds,
-            dependencies=dependencies or [],
-            metadata=metadata or {},
+            event_type=event.event_type,
+            task_id=event.task_id,
+            worker_id=event.worker_id,
+            queue_time_seconds=event.queue_time_seconds,
+            dependencies=event.dependencies or [],
+            metadata=event.metadata or {},
         )
-        if task_id in self._task_hierarchy:
-            self._task_hierarchy[task_id]['status'] = 'assigned'
-            self._task_hierarchy[task_id]['assigned_to'] = worker_id
-            self._task_hierarchy[task_id]['dependencies'] = dependencies or []
-        if worker_id in self._worker_information:
-            self._worker_information[worker_id]['current_task_id'] = task_id
-            self._worker_information[worker_id]['status'] = 'busy'
+        if event.task_id in self._task_hierarchy:
+            self._task_hierarchy[event.task_id]['status'] = 'assigned'
+            self._task_hierarchy[event.task_id]['assigned_to'] = (
+                event.worker_id
+            )
+            self._task_hierarchy[event.task_id]['dependencies'] = (
+                event.dependencies or []
+            )
+        if event.worker_id in self._worker_information:
+            self._worker_information[event.worker_id]['current_task_id'] = (
+                event.task_id
+            )
+            self._worker_information[event.worker_id]['status'] = 'busy'
 
     def log_task_started(
         self,
-        task_id: str,
-        worker_id: str,
-        metadata: Optional[Dict[str, Any]] = None,
+        event: TaskStartedEvent,
     ) -> None:
         r"""Logs when a worker starts processing a task."""
         self._log_event(
-            'task_started',
-            task_id=task_id,
-            worker_id=worker_id,
-            metadata=metadata or {},
+            event_type=event.event_type,
+            task_id=event.task_id,
+            worker_id=event.worker_id,
+            metadata=event.metadata or {},
         )
-        if task_id in self._task_hierarchy:
-            self._task_hierarchy[task_id]['status'] = 'processing'
+        if event.task_id in self._task_hierarchy:
+            self._task_hierarchy[event.task_id]['status'] = 'processing'
 
-    def log_task_completed(
-        self,
-        task_id: str,
-        worker_id: str,
-        result_summary: Optional[str] = None,
-        processing_time_seconds: Optional[float] = None,
-        token_usage: Optional[Dict[str, int]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> None:
+    def log_task_completed(self, event: TaskCompletedEvent) -> None:
         r"""Logs the successful completion of a task."""
         self._log_event(
-            'task_completed',
-            task_id=task_id,
-            worker_id=worker_id,
-            result_summary=result_summary,
-            processing_time_seconds=processing_time_seconds,
-            token_usage=token_usage or {},
-            metadata=metadata or {},
+            event_type=event.event_type,
+            task_id=event.task_id,
+            worker_id=event.worker_id,
+            result_summary=event.result_summary,
+            processing_time_seconds=event.processing_time_seconds,
+            token_usage=event.token_usage or {},
+            metadata=event.metadata or {},
         )
-        if task_id in self._task_hierarchy:
-            self._task_hierarchy[task_id]['status'] = 'completed'
-            self._task_hierarchy[task_id]['assigned_to'] = None
+        if event.task_id in self._task_hierarchy:
+            self._task_hierarchy[event.task_id]['status'] = 'completed'
+            self._task_hierarchy[event.task_id]['assigned_to'] = None
             # Store processing time in task hierarchy for display in tree
-            if processing_time_seconds is not None:
-                self._task_hierarchy[task_id]['completion_time_seconds'] = (
-                    processing_time_seconds
-                )
+            if event.processing_time_seconds is not None:
+                self._task_hierarchy[event.task_id][
+                    'completion_time_seconds'
+                ] = event.processing_time_seconds
             # Store token usage in task hierarchy for display in tree
-            if token_usage is not None:
-                self._task_hierarchy[task_id]['token_usage'] = token_usage
-        if worker_id in self._worker_information:
-            self._worker_information[worker_id]['current_task_id'] = None
-            self._worker_information[worker_id]['status'] = 'idle'
-            self._worker_information[worker_id]['tasks_completed'] = (
-                self._worker_information[worker_id].get('tasks_completed', 0)
+            if event.token_usage is not None:
+                self._task_hierarchy[event.task_id]['token_usage'] = (
+                    event.token_usage
+                )
+        if event.worker_id in self._worker_information:
+            self._worker_information[event.worker_id]['current_task_id'] = None
+            self._worker_information[event.worker_id]['status'] = 'idle'
+            self._worker_information[event.worker_id]['tasks_completed'] = (
+                self._worker_information[event.worker_id].get(
+                    'tasks_completed', 0
+                )
                 + 1
             )
 
     def log_task_failed(
         self,
-        task_id: str,
-        error_message: str,
-        worker_id: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        event: TaskFailedEvent,
     ) -> None:
         r"""Logs the failure of a task."""
         self._log_event(
-            'task_failed',
-            task_id=task_id,
-            worker_id=worker_id,
-            error_message=error_message,
-            metadata=metadata or {},
+            event_type=event.event_type,
+            task_id=event.task_id,
+            worker_id=event.worker_id,
+            error_message=event.error_message,
+            metadata=event.metadata or {},
         )
-        if task_id in self._task_hierarchy:
-            self._task_hierarchy[task_id]['status'] = 'failed'
-            self._task_hierarchy[task_id]['error'] = error_message
-            self._task_hierarchy[task_id]['assigned_to'] = None
-        if worker_id and worker_id in self._worker_information:
-            self._worker_information[worker_id]['current_task_id'] = None
-            self._worker_information[worker_id]['status'] = 'idle'
-            self._worker_information[worker_id]['tasks_failed'] = (
-                self._worker_information[worker_id].get('tasks_failed', 0) + 1
+        if event.task_id in self._task_hierarchy:
+            self._task_hierarchy[event.task_id]['status'] = 'failed'
+            self._task_hierarchy[event.task_id]['error'] = event.error_message
+            self._task_hierarchy[event.task_id]['assigned_to'] = None
+        if event.worker_id and event.worker_id in self._worker_information:
+            self._worker_information[event.worker_id]['current_task_id'] = None
+            self._worker_information[event.worker_id]['status'] = 'idle'
+            self._worker_information[event.worker_id]['tasks_failed'] = (
+                self._worker_information[event.worker_id].get(
+                    'tasks_failed', 0
+                )
+                + 1
             )
 
     def log_worker_created(
         self,
-        worker_id: str,
-        worker_type: str,
-        role: str,
-        metadata: Optional[Dict[str, Any]] = None,
+        event: WorkerCreatedEvent,
     ) -> None:
         r"""Logs the creation of a new worker."""
         self._log_event(
-            'worker_created',
-            worker_id=worker_id,
-            worker_type=worker_type,
-            role=role,
-            metadata=metadata or {},
+            event_type=event.event_type,
+            worker_id=event.worker_id,
+            worker_type=event.worker_type,
+            role=event.role,
+            metadata=event.metadata or {},
         )
-        self._worker_information[worker_id] = {
-            'type': worker_type,
-            'role': role,
+        self._worker_information[event.worker_id] = {
+            'type': event.worker_type,
+            'role': event.role,
             'status': 'idle',
             'current_task_id': None,
             'tasks_completed': 0,
             'tasks_failed': 0,
-            **(metadata or {}),
+            **(event.metadata or {}),
         }
 
     def log_worker_deleted(
         self,
-        worker_id: str,
-        reason: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        event: WorkerDeletedEvent,
     ) -> None:
         r"""Logs the deletion of a worker."""
         self._log_event(
-            'worker_deleted',
-            worker_id=worker_id,
-            reason=reason,
-            metadata=metadata or {},
+            event_type=event.event_type,
+            worker_id=event.worker_id,
+            reason=event.reason,
+            metadata=event.metadata or {},
         )
-        if worker_id in self._worker_information:
-            self._worker_information[worker_id]['status'] = 'deleted'
+        if event.worker_id in self._worker_information:
+            self._worker_information[event.worker_id]['status'] = 'deleted'
             # Or del self._worker_information[worker_id]
 
+    def log_queue_status(
+        self,
+        event: QueueStatusEvent,
+    ) -> None:
+        r"""Logs the status of a task queue."""
+        self._log_event(
+            event_type=event.event_type,
+            queue_name=event.queue_name,
+            length=event.length,
+            pending_task_ids=event.pending_task_ids or [],
+            metadata=event.metadata or {},
+        )
+
+    def log_all_tasks_completed(self, event: AllTasksCompletedEvent) -> None:
+        pass
+
     def reset_task_data(self) -> None:
         r"""Resets logs and data related to tasks, preserving worker
         information.
@@ -263,22 +283,6 @@ class WorkforceLogger:
             f"{self.workforce_id}"
         )
 
-    def log_queue_status(
-        self,
-        queue_name: str,
-        length: int,
-        pending_task_ids: Optional[List[str]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> None:
-        r"""Logs the status of a task queue."""
-        self._log_event(
-            'queue_status',
-            queue_name=queue_name,
-            length=length,
-            pending_task_ids=pending_task_ids or [],
-            metadata=metadata or {},
-        )
-
     def dump_to_json(self, file_path: str) -> None:
         r"""Dumps all log entries to a JSON file.
 

camel/societies/workforce/workforce_metrics.py

@@ -0,0 +1,33 @@
+# ========= 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 abc import ABC, abstractmethod
+from typing import Any, Dict
+
+
+class WorkforceMetrics(ABC):
+    @abstractmethod
+    def reset_task_data(self) -> None:
+        pass
+
+    @abstractmethod
+    def dump_to_json(self, file_path: str) -> None:
+        pass
+
+    @abstractmethod
+    def get_ascii_tree_representation(self) -> str:
+        pass
+
+    @abstractmethod
+    def get_kpis(self) -> Dict[str, Any]:
+        pass

camel/storages/vectordb_storages/oceanbase.py

@@ -121,10 +121,11 @@ class OceanBaseStorage(BaseVectorStorage):
             )
 
             # Get the first index parameter
-            first_index_param = next(iter(index_params))
-            self._client.create_vidx_with_vec_index_param(
-                table_name=self.table_name, vidx_param=first_index_param
-            )
+            first_index_param = next(iter(index_params), None)
+            if first_index_param is not None:
+                self._client.create_vidx_with_vec_index_param(
+                    table_name=self.table_name, vidx_param=first_index_param
+                )
 
             logger.info(f"Created table {self.table_name} with vector index")
         else:

camel/toolkits/file_toolkit.py

@@ -1201,6 +1201,171 @@ class FileToolkit(BaseToolkit):
         except Exception as e:
             return f"Error editing file: {e}"
 
+    def search_files(
+        self,
+        pattern: str,
+        file_types: Optional[List[str]] = None,
+        file_pattern: Optional[str] = None,
+        path: Optional[str] = None,
+    ) -> str:
+        r"""Search for a text pattern in files with specified extensions or
+        file patterns.
+
+        This method searches for a text pattern (case-insensitive substring
+        match) in files matching either the specified file types or a file
+        pattern. It returns structured results showing which files contain
+        the pattern, along with line numbers and matching content.
+
+        Args:
+            pattern (str): The text pattern to search for (case-insensitive
+                string match).
+            file_types (Optional[List[str]]): List of file extensions to
+                search (e.g., ["md", "txt", "py"]). Do not include the dot.
+                If not provided and file_pattern is also not provided,
+                defaults to ["md"] (markdown files). Ignored if file_pattern
+                is provided. (default: :obj:`None`)
+            file_pattern (Optional[str]): Glob pattern for matching files
+                (e.g., "*_workflow.md", "test_*.py"). If provided, this
+                overrides file_types. (default: :obj:`None`)
+            path (Optional[str]): Directory to search in. If not provided,
+                uses the working_directory. Can be relative or absolute.
+                (default: :obj:`None`)
+
+        Returns:
+            str: JSON-formatted string containing search results with the
+                structure:
+                {
+                    "pattern": "search_pattern",
+                    "searched_path": "/absolute/path",
+                    "file_types": ["md", "txt"],
+                    "file_pattern": "*_workflow.md",
+                    "matches": [
+                        {
+                            "file": "relative/path/to/file.md",
+                            "line": 42,
+                            "content": "matching line content"
+                        },
+                        ...
+                    ],
+                    "total_matches": 10,
+                    "files_searched": 5
+                }
+                If an error occurs, returns a JSON string with an "error" key.
+        """
+        import json
+
+        try:
+            # resolve search path
+            if path:
+                path_obj = Path(path)
+                if not path_obj.is_absolute():
+                    search_path = (self.working_directory / path_obj).resolve()
+                else:
+                    search_path = path_obj.resolve()
+            else:
+                search_path = self.working_directory
+
+            # validate that search path exists
+            if not search_path.exists():
+                return json.dumps(
+                    {"error": f"Search path does not exist: {search_path}"}
+                )
+
+            if not search_path.is_dir():
+                return json.dumps(
+                    {"error": f"Search path is not a directory: {search_path}"}
+                )
+
+            # collect all matching files
+            matching_files: List[Path] = []
+
+            if file_pattern:
+                # use file_pattern if provided (overrides file_types)
+                pattern_glob = f"**/{file_pattern}"
+                matching_files.extend(search_path.rglob(pattern_glob))
+            else:
+                # use file_types if file_pattern not provided
+                if file_types is None:
+                    file_types = ["md"]
+
+                # normalize and deduplicate file types
+                normalized_types = set()
+                for file_type in file_types:
+                    file_type = file_type.lstrip('.')
+                    if file_type:  # skip empty strings
+                        normalized_types.add(file_type)
+
+                for file_type in normalized_types:
+                    # use rglob for recursive search
+                    pattern_glob = f"**/*.{file_type}"
+                    matching_files.extend(search_path.rglob(pattern_glob))
+
+            # search through files (case-insensitive)
+            matches = []
+            files_searched = 0
+            pattern_lower = pattern.lower()
+
+            for file_path in matching_files:
+                files_searched += 1
+                try:
+                    # read file content
+                    content = file_path.read_text(
+                        encoding=self.default_encoding
+                    )
+                    lines = content.splitlines()
+
+                    # search each line for pattern (case-insensitive)
+                    for line_num, line in enumerate(lines, start=1):
+                        if pattern_lower in line.lower():
+                            # get relative path for cleaner output
+                            try:
+                                relative_path = file_path.relative_to(
+                                    search_path
+                                )
+                            except ValueError:
+                                relative_path = file_path
+
+                            matches.append(
+                                {
+                                    "file": str(relative_path),
+                                    "line": line_num,
+                                    "content": line.strip(),
+                                }
+                            )
+
+                except (UnicodeDecodeError, PermissionError) as e:
+                    # skip files that can't be read
+                    logger.debug(f"Skipping file {file_path}: {e}")
+                    continue
+
+            # build result
+            result = {
+                "pattern": pattern,
+                "searched_path": str(search_path),
+                "matches": matches,
+                "total_matches": len(matches),
+                "files_searched": files_searched,
+            }
+
+            # include file_pattern or file_types in result
+            if file_pattern:
+                result["file_pattern"] = file_pattern
+            else:
+                result["file_types"] = (
+                    sorted(normalized_types) if normalized_types else ["md"]
+                )
+
+            logger.info(
+                f"Search completed: found {len(matches)} matches "
+                f"in {files_searched} files"
+            )
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            error_msg = f"Error during file search: {e}"
+            logger.error(error_msg)
+            return json.dumps({"error": error_msg})
+
     def get_tools(self) -> List[FunctionTool]:
         r"""Return a list of FunctionTool objects representing the functions
         in the toolkit.
@@ -1213,6 +1378,7 @@ class FileToolkit(BaseToolkit):
             FunctionTool(self.write_to_file),
             FunctionTool(self.read_file),
             FunctionTool(self.edit_file),
+            FunctionTool(self.search_files),
         ]