camel-ai 0.1.5.9__py3-none-any.whl → 0.1.6.1__py3-none-any.whl

camel/workforce/task_channel.py

@@ -0,0 +1,173 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+import asyncio
+from enum import Enum
+from typing import Dict, List, Optional
+
+from camel.tasks import Task
+
+
+class PacketStatus(Enum):
+    r"""The status of a packet. The packet can be in one of the following
+    states:
+    - ``SENT``: The packet has been sent to a worker.
+    - ``RETURNED``: The packet has been returned by the worker, meaning that
+            the status of the task inside has been updated.
+    - ``ARCHIVED``: The packet has been archived, meaning that the content of
+            the task inside will not be changed. The task is considered
+            as a dependency.
+    """
+
+    SENT = "SENT"
+    RETURNED = "RETURNED"
+    ARCHIVED = "ARCHIVED"
+
+
+class Packet:
+    r"""The basic element inside the channel. A task is wrapped inside a
+    packet. The packet will contain the task, along with the task's assignee,
+    and the task's status.
+
+    Args:
+        task (Task): The task that is wrapped inside the packet.
+        publisher_id (str): The ID of the workforce that published the task.
+        assignee_id (str): The ID of the workforce that is assigned
+            to the task. Defaults to None, meaning that the task is posted as
+            a dependency in the channel.
+
+    Attributes:
+        task (Task): The task that is wrapped inside the packet.
+        publisher_id (str): The ID of the workforce that published the task.
+        assignee_id (Optional[str], optional): The ID of the workforce that is
+            assigned to the task. Would be None if the task is a dependency.
+            Defaults to None.
+        status (PacketStatus): The status of the task.
+    """
+
+    def __init__(
+        self,
+        task: Task,
+        publisher_id: str,
+        assignee_id: Optional[str] = None,
+        status: PacketStatus = PacketStatus.SENT,
+    ):
+        self.task = task
+        self.publisher_id = publisher_id
+        self.assignee_id = assignee_id
+        self.status = status
+
+    def __repr__(self):
+        return (
+            f"Packet(publisher_id={self.publisher_id}, assignee_id="
+            f"{self.assignee_id}, status={self.status})"
+        )
+
+
+class TaskChannel:
+    r"""An internal class used by Workforce to manage tasks."""
+
+    def __init__(self) -> None:
+        self._task_id_list: List[str] = []
+        self._condition = asyncio.Condition()
+        self._task_dict: Dict[str, Packet] = {}
+
+    async def get_returned_task_by_publisher(self, publisher_id: str) -> Task:
+        await self.print_channel()
+        async with self._condition:
+            while True:
+                for task_id in self._task_id_list:
+                    packet = self._task_dict[task_id]
+                    if packet.publisher_id != publisher_id:
+                        continue
+                    if packet.status != PacketStatus.RETURNED:
+                        continue
+                    return packet.task
+                await self._condition.wait()
+
+    async def get_assigned_task_by_assignee(self, assignee_id: str) -> Task:
+        async with self._condition:
+            while True:
+                for task_id in self._task_id_list:
+                    packet = self._task_dict[task_id]
+                    if (
+                        packet.status == PacketStatus.SENT
+                        and packet.assignee_id == assignee_id
+                    ):
+                        return packet.task
+                await self._condition.wait()
+
+    async def post_task(
+        self, task: Task, publisher_id: str, assignee_id: str
+    ) -> None:
+        r"""Send a task to the channel with specified publisher and assignee,
+        along with the dependency of the task."""
+        async with self._condition:
+            self._task_id_list.append(task.id)
+            packet = Packet(task, publisher_id, assignee_id)
+            self._task_dict[packet.task.id] = packet
+            self._condition.notify_all()
+
+    async def post_dependency(
+        self, dependency: Task, publisher_id: str
+    ) -> None:
+        r"""Post a dependency to the channel. A dependency is a task that is
+        archived, and will be referenced by other tasks."""
+        async with self._condition:
+            self._task_id_list.append(dependency.id)
+            packet = Packet(
+                dependency, publisher_id, status=PacketStatus.ARCHIVED
+            )
+            self._task_dict[packet.task.id] = packet
+            self._condition.notify_all()
+
+    async def return_task(self, task_id: str) -> None:
+        r"""Return a task to the sender, indicating that the task has been
+        processed by the worker."""
+        async with self._condition:
+            packet = self._task_dict[task_id]
+            packet.status = PacketStatus.RETURNED
+            self._condition.notify_all()
+
+    async def archive_task(self, task_id: str) -> None:
+        r"""Archive a task in channel, making it to become a dependency."""
+        async with self._condition:
+            packet = self._task_dict[task_id]
+            packet.status = PacketStatus.ARCHIVED
+            self._condition.notify_all()
+
+    async def remove_task(self, task_id: str) -> None:
+        async with self._condition:
+            self._task_id_list.remove(task_id)
+            self._task_dict.pop(task_id)
+            self._condition.notify_all()
+
+    async def get_dependency_ids(self) -> List[str]:
+        async with self._condition:
+            dependency_ids = []
+            for task_id in self._task_id_list:
+                packet = self._task_dict[task_id]
+                if packet.status == PacketStatus.ARCHIVED:
+                    dependency_ids.append(task_id)
+            return dependency_ids
+
+    async def get_task_by_id(self, task_id: str) -> Task:
+        async with self._condition:
+            if task_id not in self._task_id_list:
+                raise ValueError(f"Task {task_id} not found.")
+            return self._task_dict[task_id].task
+
+    async def print_channel(self):
+        async with self._condition:
+            print(self._task_dict)
+            print(self._task_id_list)

camel/workforce/utils.py

@@ -0,0 +1,97 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+import re
+from functools import wraps
+from typing import Callable
+
+
+class NodeConf:
+    def __init__(self, role: str, system: str, description: str):
+        self.role = role
+        self.system = system
+        self.description = description
+
+
+# TODO: integrate structured response directly instead of parsing
+def parse_create_node_resp(response: str) -> NodeConf:
+    r"""Parses the response of the new workforce creation from the manager
+    agent."""
+    config = re.search(r"(<workforce>.*</workforce>)", response, re.DOTALL)
+    if config is None:
+        raise ValueError("No workforce configuration found in the response.")
+    config_raw = config.group(1)
+
+    try:
+        import xml.etree.ElementTree as ET
+
+        root = ET.fromstring(config_raw)
+        workforce_info = {child.tag: child.text for child in root}
+    except Exception as e:
+        raise ValueError(f"Failed to parse workforce configuration: {e}")
+
+    if (
+        "role" not in workforce_info
+        or "system" not in workforce_info
+        or "description" not in workforce_info
+    ):
+        raise ValueError("Missing required fields in workforce configuration.")
+
+    return NodeConf(
+        role=workforce_info["role"] or "",
+        system=workforce_info["system"] or "",
+        description=workforce_info["description"] or "",
+    )
+
+
+def parse_assign_task_resp(response: str) -> str:
+    r"""Parses the response of the task assignment from the manager agent."""
+    assignee_id = re.search(r"<id>(.*)</id>", response)
+    if assignee_id is None:
+        raise ValueError("No assignee found in the response.")
+    return assignee_id.group(1)
+
+
+def parse_task_result_resp(response: str) -> str:
+    r"""Parses the result of the task from the signle agent workforce."""
+    task_result = re.search(r"<result>(.*)</result>", response, re.DOTALL)
+    failed_tag = re.search(r"<failed></failed>", response)
+    if failed_tag:
+        task_result = None
+    if task_result is None:
+        raise ValueError("No result found in the response.")
+    return task_result.group(1)
+
+
+def check_if_running(running: bool) -> Callable:
+    r"""Check if the workforce is (not) running, specified the boolean value.
+    If the workforce is not in the expected status, raise an exception.
+
+    Raises:
+        RuntimeError: If the workforce is not in the expected status.
+    """
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(self, *args, **kwargs):
+            if self._running != running:
+                status = "not running" if running else "running"
+                raise RuntimeError(
+                    f"The workforce is {status}. Cannot perform the "
+                    f"operation {func.__name__}."
+                )
+            return func(self, *args, **kwargs)
+
+        return wrapper
+
+    return decorator

camel/workforce/worker_node.py

@@ -0,0 +1,115 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import List
+
+from colorama import Fore
+
+from camel.tasks.task import Task, TaskState
+from camel.workforce.base import BaseNode
+from camel.workforce.task_channel import TaskChannel
+from camel.workforce.utils import check_if_running
+
+
+class WorkerNode(BaseNode, ABC):
+    r"""A worker node that works on tasks. It is the basic unit of task
+    processing in the workforce system.
+
+    Args:
+        description (str): Description of the node.
+
+    """
+
+    # TODO: Make RolePlaying and Agent scceed from one parent class, so that
+    #   we don't need two different classes for the worker node.
+
+    def __init__(
+        self,
+        description: str,
+    ) -> None:
+        super().__init__(description)
+
+    @abstractmethod
+    async def _process_task(
+        self, task: Task, dependencies: List[Task]
+    ) -> TaskState:
+        r"""Processes a task based on its dependencies.
+
+        Returns:
+            'DONE' if the task is successfully processed,
+            'FAILED' if the processing fails.
+        """
+
+    async def _get_assigned_task(self) -> Task:
+        r"""Get the task assigned to this node from the channel."""
+        return await self._channel.get_assigned_task_by_assignee(self.node_id)
+
+    @staticmethod
+    def _get_dep_tasks_info(dependencies: List[Task]) -> str:
+        result_lines = [
+            f"id: {dep_task.id}, content: {dep_task.content}. "
+            f"result: {dep_task.result}."
+            for dep_task in dependencies
+        ]
+        result_str = "\n".join(result_lines)
+        return result_str
+
+    @check_if_running(False)
+    def set_channel(self, channel: TaskChannel):
+        self._channel = channel
+
+    @check_if_running(False)
+    async def _listen_to_channel(self):
+        """Continuously listen to the channel, process the task that are
+        assigned to this node, and update the result and status of the task.
+
+        This method should be run in an event loop, as it will run
+            indefinitely.
+        """
+        self._running = True
+        print(f"{Fore.GREEN}Worker node {self.node_id} started.{Fore.RESET}")
+
+        while True:
+            # get the earliest task assigned to this node
+            task = await self._get_assigned_task()
+            print(
+                f'worker node {self.node_id} get task:',
+                task.id,
+                task.content,
+            )
+            # get the Task instance of dependencies
+            dependency_ids = await self._channel.get_dependency_ids()
+            task_dependencies = [
+                await self._channel.get_task_by_id(dep_id)
+                for dep_id in dependency_ids
+            ]
+
+            # process the task
+            task_state = await self._process_task(task, task_dependencies)
+
+            # update the result and status of the task
+            task.set_state(task_state)
+
+            await self._channel.return_task(task.id)
+
+    @check_if_running(False)
+    async def start(self):
+        await self._listen_to_channel()
+
+    @check_if_running(True)
+    def stop(self):
+        self._running = False
+        return

camel/workforce/workforce.py

@@ -0,0 +1,49 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+import asyncio
+
+from camel.tasks import Task
+from camel.workforce.manager_node import ManagerNode
+from camel.workforce.task_channel import TaskChannel
+
+
+class Workforce:
+    r"""A class representing a workforce system.
+
+    Args:
+        name (str, optional): The name of the workforce system. Defaults to
+            `"CAMEL Workforce"`.
+        description (str, optional): A description of the workforce system.
+            Defaults to `"A workforce system for managing tasks."`.
+    """
+
+    def __init__(
+        self,
+        root_node: ManagerNode,
+        name: str = "CAMEL Workforce",
+        description: str = "A workforce system for managing tasks.",
+    ) -> None:
+        self.name = name
+        self.description = description
+        self._root_node = root_node
+
+    def process_task(self, task: Task) -> Task:
+        self._root_node.set_main_task(task)
+        shared_channel = TaskChannel()
+        self._root_node.set_channel(shared_channel)
+
+        # start the root workforce
+        asyncio.run(self._root_node.start())
+
+        return task

camel/workforce/workforce_prompt.py

@@ -0,0 +1,125 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+from camel.prompts import TextPrompt
+
+# ruff: noqa: E501
+CREATE_NODE_PROMPT = TextPrompt(
+    """You need to use the given information to create a new workforce for solving the category of tasks of the given one.
+The content of the given task is:
+
+{content}
+
+Following is the information of the existing workforces. The format is <ID>: <description>.
+
+{child_nodes_info}
+
+You must return the following information:
+1. The role of the agent working in the workforce, e.g. "programmer", "researcher", "product owner". This should be enclosed within the <role></role> tags.
+2. The system message that will be sent to the agent, enclosed within the <system></system> tags.
+3. The description of the workforce, enclosed within the <description></description> tags.
+
+Also, all of the info should be enclosed within a <workforce> tag. For example:
+
+<workforce>
+<role>programmer</role>
+<system>You are a python programmer.</system>
+<description>a python programmer.</description>
+</workforce>
+
+You should ensure that the workforce created is capable of solving all the tasks in the same category as the given one, don't make it too specific.
+Also, there should be no big overlap between the new workforce and the existing ones.
+The information returned should be concise and clear. Each pair of tag can only appear once.
+"""
+)
+
+ASSIGN_TASK_PROMPT = TextPrompt(
+    """You need to assign the task to a workforce.
+The content of the task is:
+
+{content}
+
+Following is the information of the existing workforces. The format is <ID>: <description>.
+
+{child_nodes_info}
+
+You must return the ID of the workforce that you think is most capable of doing the task. The ID should be enclosed within the <id></id> tags, for example:
+
+<id>1</id>
+"""
+)
+
+PROCESS_TASK_PROMPT = TextPrompt(
+    """You need to process the task. It is recommended that tools be actively called when needed.
+The content of the task is:
+
+{content}
+
+The type of the task is:
+
+{type}
+
+To process this task, here is some information on several dependent tasks:
+
+{dependency_task_info}
+
+You must return the result of the given task. The result should be enclosed within the <result></result> tags, for example:
+
+<result>Today, you requested information about the current weather conditions. The weather today in New York City is partly cloudy with a high of 75°F (24°C) and a low of 59°F (15°C). There is a 10 percent chance of rain with winds coming from the northeast at 5 mph. Humidity levels are at 60%. It's a perfect day to spend some time outdoors, perhaps in one of the city's beautiful parks.</result>
+
+if you are not able to process the task, you need to return <failed></failed> tags.
+"""
+)
+
+
+ROLEPLAY_PROCESS_TASK_PROMPT = TextPrompt(
+    """You need to process the task. It is recommended that tools be actively called when needed.
+The content of the task is:
+
+{content}
+
+The type of the task is:
+
+{type}
+
+To process this task, here is some information on several dependent tasks:
+
+{dependency_task_info}
+
+You must return the result of the given task.
+
+"""
+)
+
+# TODO: improve prompt quality
+ROLEPLAY_SUMMERIZE_PROMPT = TextPrompt(
+    """You need to process the task.
+The content of the task is:
+
+{content}
+
+The type of the task is:
+
+{type}
+
+To process this task, here are the chat history of AI user and AI assistant:
+
+{chat_history}
+
+You must summerize the chat history of the return the result of the given task. The result should be enclosed within the <result></result> tags, for example:
+
+<result>Today, you requested information about the current weather conditions. The weather today in New York City is partly cloudy with a high of 75°F (24°C) and a low of 59°F (15°C). There is a 10 percent chance of rain with winds coming from the northeast at 5 mph. Humidity levels are at 60%. It's a perfect day to spend some time outdoors, perhaps in one of the city's beautiful parks.</result>
+
+if you are not able to process the task, you need to return <failed></failed> tags.
+"""
+)

{camel_ai-0.1.5.9.dist-info → camel_ai-0.1.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: camel-ai
-Version: 0.1.5.9
+Version: 0.1.6.1
 Summary: Communicative Agents for AI Society Study
 Home-page: https://www.camel-ai.org/
 License: Apache-2.0
@@ -24,6 +24,7 @@ Provides-Extra: tools
 Provides-Extra: vector-databases
 Requires-Dist: PyMuPDF (>=1.22.5,<2.0.0) ; extra == "tools" or extra == "all"
 Requires-Dist: accelerate (>=0,<1) ; extra == "huggingface-agent" or extra == "all"
+Requires-Dist: agentops (>=0.3.6,<0.4.0) ; extra == "tools" or extra == "all"
 Requires-Dist: anthropic (>=0.29.0,<0.30.0)
 Requires-Dist: beautifulsoup4 (>=4,<5) ; extra == "tools" or extra == "all"
 Requires-Dist: cohere (>=4.56,<5.0) ; extra == "retrievers" or extra == "all"
@@ -36,6 +37,8 @@ Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "tools" or extra == "all"
 Requires-Dist: docstring-parser (>=0.15,<0.16)
 Requires-Dist: docx2txt (>=0.8,<0.9) ; extra == "tools" or extra == "all"
 Requires-Dist: duckduckgo-search (>=6.1.0,<7.0.0) ; extra == "tools" or extra == "all"
+Requires-Dist: eval-type-backport (==0.2.0)
+Requires-Dist: firecrawl-py (>=0.0.20,<0.0.21) ; extra == "tools" or extra == "all"
 Requires-Dist: google-generativeai (>=0.6.0,<0.7.0) ; extra == "model-platforms" or extra == "all"
 Requires-Dist: googlemaps (>=4.10.0,<5.0.0) ; extra == "tools" or extra == "all"
 Requires-Dist: groq (>=0.5.0,<0.6.0)
@@ -195,7 +198,7 @@ conda create --name camel python=3.9
 conda activate camel
 
 # Clone github repo
-git clone -b v0.1.5.9 https://github.com/camel-ai/camel.git
+git clone -b v0.1.6.1 https://github.com/camel-ai/camel.git
 
 # Change directory into project directory
 cd camel