camel-ai 0.2.0__py3-none-any.whl → 0.2.1a0__py3-none-any.whl

camel/__init__.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
-__version__ = '0.2.0'
+__version__ = '0.2.1a'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -15,6 +15,8 @@ from __future__ import annotations
 
 import json
 import logging
+import re
+import uuid
 from collections import defaultdict
 from typing import (
     TYPE_CHECKING,
@@ -28,6 +30,7 @@ from typing import (
 )
 
 from openai.types.chat import ChatCompletionMessageToolCall
+from openai.types.chat.chat_completion_message_tool_call import Function
 from pydantic import BaseModel
 
 from camel.agents.base import BaseAgent
@@ -190,7 +193,7 @@ class ChatAgent(BaseAgent):
                 tool.get_openai_tool_schema() for tool in all_tools
             ]
             self.model_backend.model_config_dict['tools'] = tool_schema_list
-
+            self.tool_schema_list = tool_schema_list
         self.model_config_dict = self.model_backend.model_config_dict
 
         self.model_token_limit = token_limit or self.model_backend.token_limit
@@ -206,6 +209,56 @@ class ChatAgent(BaseAgent):
         self.response_terminators = response_terminators or []
         self.init_messages()
 
+    # ruff: noqa: E501
+    def _generate_tool_prompt(self, tool_schema_list: List[Dict]) -> str:
+        tool_prompts = []
+
+        for tool in tool_schema_list:
+            tool_info = tool['function']
+            tool_name = tool_info['name']
+            tool_description = tool_info['description']
+            tool_json = json.dumps(tool_info, indent=4)
+
+            prompt = f"Use the function '{tool_name}' to '{tool_description}':\n{tool_json}\n"
+            tool_prompts.append(prompt)
+
+        tool_prompt_str = "\n".join(tool_prompts)
+
+        final_prompt = f'''
+    # Tool prompt
+    TOOL_PROMPT = f"""
+    You have access to the following functions:
+
+    {tool_prompt_str}
+
+    If you choose to call a function ONLY reply in the following format with no prefix or suffix:
+
+    <function=example_function_name>{{"example_name": "example_value"}}</function>
+
+    Reminder:
+    - Function calls MUST follow the specified format, start with <function= and end with </function>
+    - Required parameters MUST be specified
+    - Only call one function at a time
+    - Put the entire function call reply on one line
+    - If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
+    """
+    '''
+        return final_prompt
+
+    def _parse_tool_response(self, response: str):
+        function_regex = r"<function=(\w+)>(.*?)</function>"
+        match = re.search(function_regex, response)
+
+        if match:
+            function_name, args_string = match.groups()
+            try:
+                args = json.loads(args_string)
+                return {"function": function_name, "arguments": args}
+            except json.JSONDecodeError as error:
+                print(f"Error parsing function arguments: {error}")
+                return None
+        return None
+
     def reset(self):
         r"""Resets the :obj:`ChatAgent` to its initial state and returns the
         stored messages.
@@ -367,89 +420,221 @@ class ChatAgent(BaseAgent):
                 a boolean indicating whether the chat session has terminated,
                 and information about the chat session.
         """
-        self.update_memory(input_message, OpenAIBackendRole.USER)
+        if (
+            isinstance(self.model_type, ModelType)
+            and "lama" in self.model_type.value
+            or isinstance(self.model_type, str)
+            and "lama" in self.model_type
+        ):
+            if self.model_backend.model_config_dict['tools']:
+                tool_prompt = self._generate_tool_prompt(self.tool_schema_list)
+
+                tool_sys_msg = BaseMessage.make_assistant_message(
+                    role_name="Assistant",
+                    content=tool_prompt,
+                )
 
-        tool_call_records: List[FunctionCallingRecord] = []
-        while True:
-            # Check if token has exceeded
-            try:
-                openai_messages, num_tokens = self.memory.get_context()
-            except RuntimeError as e:
-                return self._step_token_exceed(
-                    e.args[1], tool_call_records, "max_tokens_exceeded"
+                self.update_memory(tool_sys_msg, OpenAIBackendRole.SYSTEM)
+
+            self.update_memory(input_message, OpenAIBackendRole.USER)
+
+            tool_call_records: List[FunctionCallingRecord] = []
+            while True:
+                # Check if token has exceeded
+                try:
+                    openai_messages, num_tokens = self.memory.get_context()
+                except RuntimeError as e:
+                    return self._step_token_exceed(
+                        e.args[1], tool_call_records, "max_tokens_exceeded"
+                    )
+
+                (
+                    response,
+                    output_messages,
+                    finish_reasons,
+                    usage_dict,
+                    response_id,
+                ) = self._step_model_response(openai_messages, num_tokens)
+                # If the model response is not a function call, meaning the
+                # model has generated a message response, break the loop
+                if (
+                    not self.is_tools_added()
+                    or not isinstance(response, ChatCompletion)
+                    or "</function>" not in response.choices[0].message.content  # type: ignore[operator]
+                ):
+                    break
+
+                parsed_content = self._parse_tool_response(
+                    response.choices[0].message.content  # type: ignore[arg-type]
                 )
 
-            (
-                response,
+                response.choices[0].message.tool_calls = [
+                    ChatCompletionMessageToolCall(
+                        id=str(uuid.uuid4()),
+                        function=Function(
+                            arguments=str(parsed_content["arguments"]).replace(
+                                "'", '"'
+                            ),
+                            name=str(parsed_content["function"]),
+                        ),
+                        type="function",
+                    )
+                ]
+
+                # Check for external tool call
+                tool_call_request = response.choices[0].message.tool_calls[0]
+                if tool_call_request.function.name in self.external_tool_names:
+                    # if model calls an external tool, directly return the
+                    # request
+                    info = self._step_get_info(
+                        output_messages,
+                        finish_reasons,
+                        usage_dict,
+                        response_id,
+                        tool_call_records,
+                        num_tokens,
+                        tool_call_request,
+                    )
+                    return ChatAgentResponse(
+                        msgs=output_messages,
+                        terminated=self.terminated,
+                        info=info,
+                    )
+
+                # Normal function calling
+                tool_call_records.append(
+                    self._step_tool_call_and_update(response)
+                )
+
+            if (
+                output_schema is not None
+                and self.model_type.supports_tool_calling
+            ):
+                (
+                    output_messages,
+                    finish_reasons,
+                    usage_dict,
+                    response_id,
+                    tool_call,
+                    num_tokens,
+                ) = self._structure_output_with_function(output_schema)
+                tool_call_records.append(tool_call)
+
+            info = self._step_get_info(
                 output_messages,
                 finish_reasons,
                 usage_dict,
                 response_id,
-            ) = self._step_model_response(openai_messages, num_tokens)
+                tool_call_records,
+                num_tokens,
+            )
 
-            # If the model response is not a function call, meaning the model
-            # has generated a message response, break the loop
-            if (
-                not self.is_tools_added()
-                or not isinstance(response, ChatCompletion)
-                or response.choices[0].message.tool_calls is None
-            ):
-                break
+            if len(output_messages) == 1:
+                # Auto record if the output result is a single message
+                self.record_message(output_messages[0])
+            else:
+                logger.warning(
+                    "Multiple messages returned in `step()`, message won't be "
+                    "recorded automatically. Please call `record_message()` "
+                    "to record the selected message manually."
+                )
 
-            # Check for external tool call
-            tool_call_request = response.choices[0].message.tool_calls[0]
-            if tool_call_request.function.name in self.external_tool_names:
-                # if model calls an external tool, directly return the request
-                info = self._step_get_info(
+            return ChatAgentResponse(
+                msgs=output_messages, terminated=self.terminated, info=info
+            )
+
+        else:
+            self.update_memory(input_message, OpenAIBackendRole.USER)
+
+            tool_call_records: List[FunctionCallingRecord] = []  # type: ignore[no-redef]
+            while True:
+                # Check if token has exceeded
+                try:
+                    openai_messages, num_tokens = self.memory.get_context()
+                except RuntimeError as e:
+                    return self._step_token_exceed(
+                        e.args[1], tool_call_records, "max_tokens_exceeded"
+                    )
+
+                (
+                    response,
                     output_messages,
                     finish_reasons,
                     usage_dict,
                     response_id,
-                    tool_call_records,
-                    num_tokens,
-                    tool_call_request,
-                )
-                return ChatAgentResponse(
-                    msgs=output_messages, terminated=self.terminated, info=info
+                ) = self._step_model_response(openai_messages, num_tokens)
+                # If the model response is not a function call, meaning the
+                # model has generated a message response, break the loop
+                if (
+                    not self.is_tools_added()
+                    or not isinstance(response, ChatCompletion)
+                    or response.choices[0].message.tool_calls is None
+                ):
+                    break
+
+                # Check for external tool call
+                tool_call_request = response.choices[0].message.tool_calls[0]
+
+                if tool_call_request.function.name in self.external_tool_names:
+                    # if model calls an external tool, directly return the
+                    # request
+                    info = self._step_get_info(
+                        output_messages,
+                        finish_reasons,
+                        usage_dict,
+                        response_id,
+                        tool_call_records,
+                        num_tokens,
+                        tool_call_request,
+                    )
+                    return ChatAgentResponse(
+                        msgs=output_messages,
+                        terminated=self.terminated,
+                        info=info,
+                    )
+
+                # Normal function calling
+                tool_call_records.append(
+                    self._step_tool_call_and_update(response)
                 )
 
-            # Normal function calling
-            tool_call_records.append(self._step_tool_call_and_update(response))
+            if (
+                output_schema is not None
+                and self.model_type.supports_tool_calling
+            ):
+                (
+                    output_messages,
+                    finish_reasons,
+                    usage_dict,
+                    response_id,
+                    tool_call,
+                    num_tokens,
+                ) = self._structure_output_with_function(output_schema)
+                tool_call_records.append(tool_call)
 
-        if output_schema is not None and self.model_type.supports_tool_calling:
-            (
+            info = self._step_get_info(
                 output_messages,
                 finish_reasons,
                 usage_dict,
                 response_id,
-                tool_call,
+                tool_call_records,
                 num_tokens,
-            ) = self._structure_output_with_function(output_schema)
-            tool_call_records.append(tool_call)
+            )
 
-        info = self._step_get_info(
-            output_messages,
-            finish_reasons,
-            usage_dict,
-            response_id,
-            tool_call_records,
-            num_tokens,
-        )
+            if len(output_messages) == 1:
+                # Auto record if the output result is a single message
+                self.record_message(output_messages[0])
+            else:
+                logger.warning(
+                    "Multiple messages returned in `step()`, message won't be "
+                    "recorded automatically. Please call `record_message()` "
+                    "to record the selected message manually."
+                )
 
-        if len(output_messages) == 1:
-            # Auto record if the output result is a single message
-            self.record_message(output_messages[0])
-        else:
-            logger.warning(
-                "Multiple messages returned in `step()`, message won't be "
-                "recorded automatically. Please call `record_message()` to "
-                "record the selected message manually."
+            return ChatAgentResponse(
+                msgs=output_messages, terminated=self.terminated, info=info
             )
 
-        return ChatAgentResponse(
-            msgs=output_messages, terminated=self.terminated, info=info
-        )
-
     async def step_async(
         self,
         input_message: BaseMessage,
@@ -622,9 +807,11 @@ class ChatAgent(BaseAgent):
 
         # Replace the original tools with the structuring function
         self.func_dict = {func.get_function_name(): func.func}
+        self.model_backend.model_config_dict = original_model_dict.copy()
         self.model_backend.model_config_dict["tools"] = [
             func.get_openai_tool_schema()
         ]
+        self.model_backend.model_config_dict["tool_choice"] = "required"
 
         openai_messages, num_tokens = self.memory.get_context()
         (

camel/loaders/firecrawl_reader.py

@@ -49,7 +49,6 @@ class Firecrawl:
         self,
         url: str,
         params: Optional[Dict[str, Any]] = None,
-        wait_until_done: bool = True,
         **kwargs: Any,
     ) -> Any:
         r"""Crawl a URL and all accessible subpages. Customize the crawl by
@@ -60,14 +59,12 @@ class Firecrawl:
             url (str): The URL to crawl.
             params (Optional[Dict[str, Any]]): Additional parameters for the
                 crawl request. Defaults to `None`.
-            wait_until_done (bool): Whether to wait until the crawl job is
-                completed. Defaults to `True`.
             **kwargs (Any): Additional keyword arguments, such as
-                `poll_interval`, `idempotency_key`, etc.
+                `poll_interval`, `idempotency_key`.
 
         Returns:
-            Any: The list content of the URL if `wait_until_done` is True;
-                otherwise, a string job ID.
+            Any: The crawl job ID or the crawl results if waiting until
+                completion.
 
         Raises:
             RuntimeError: If the crawling process fails.
@@ -78,13 +75,8 @@ class Firecrawl:
                 url=url,
                 params=params,
                 **kwargs,
-                wait_until_done=wait_until_done,
-            )
-            return (
-                crawl_response
-                if wait_until_done
-                else crawl_response.get("jobId")
             )
+            return crawl_response
         except Exception as e:
             raise RuntimeError(f"Failed to crawl the URL: {e}")
 
@@ -103,7 +95,10 @@ class Firecrawl:
         """
 
         try:
-            crawl_result = self.app.crawl_url(url=url)
+            crawl_result = self.app.crawl_url(
+                url,
+                {'formats': ['markdown']},
+            )
             if not isinstance(crawl_result, list):
                 raise ValueError("Unexpected response format")
             markdown_contents = [
@@ -180,41 +175,14 @@ class Firecrawl:
             data = self.app.scrape_url(
                 url,
                 {
-                    'extractorOptions': {
-                        "mode": "llm-extraction",
-                        "extractionPrompt": "Based on the information on "
-                        "the page, extract the information from the schema.",
-                        'extractionSchema': output_schema.model_json_schema(),
-                    },
-                    'pageOptions': {'onlyMainContent': True},
+                    'formats': ['extract'],
+                    'extract': {'schema': output_schema.model_json_schema()},
                 },
             )
-            return data.get("llm_extraction", {})
+            return data.get("extract", {})
         except Exception as e:
             raise RuntimeError(f"Failed to perform structured scrape: {e}")
 
-    def tidy_scrape(self, url: str) -> str:
-        r"""Only return the main content of the page, excluding headers,
-        navigation bars, footers, etc. in Markdown format.
-
-        Args:
-            url (str): The URL to read.
-
-        Returns:
-            str: The markdown content of the URL.
-
-        Raises:
-            RuntimeError: If the scrape process fails.
-        """
-
-        try:
-            scrape_result = self.app.scrape_url(
-                url, {'pageOptions': {'onlyMainContent': True}}
-            )
-            return scrape_result.get("markdown", "")
-        except Exception as e:
-            raise RuntimeError(f"Failed to perform tidy scrape: {e}")
-
     def map_site(
         self, url: str, params: Optional[Dict[str, Any]] = None
     ) -> list:

camel/models/mistral_model.py

@@ -93,7 +93,7 @@ class MistralModel(BaseModelBackend):
                         "name": tool_call.function.name,  # type: ignore[union-attr]
                         "arguments": tool_call.function.arguments,  # type: ignore[union-attr]
                     },
-                    type=tool_call.TYPE,  # type: ignore[union-attr]
+                    type=tool_call.type,  # type: ignore[union-attr]
                 )
                 for tool_call in response.choices[0].message.tool_calls
             ]

camel/tasks/task.py

@@ -93,6 +93,10 @@ class Task(BaseModel):
 
     result: Optional[str] = ""
 
+    failure_count: int = 0
+
+    additional_info: Optional[str] = None
+
     @classmethod
     def from_message(cls, message: BaseMessage) -> "Task":
         r"""Create a task from a message.
@@ -193,7 +197,7 @@ class Task(BaseModel):
     def decompose(
         self,
         agent: ChatAgent,
-        template: TextPrompt = TASK_DECOMPOSE_PROMPT,
+        prompt: Optional[str] = None,
         task_parser: Callable[[str, str], List["Task"]] = parse_response,
     ) -> List["Task"]:
         r"""Decompose a task to a list of sub-tasks. It can be used for data
@@ -201,8 +205,8 @@ class Task(BaseModel):
 
         Args:
             agent (ChatAgent): An agent that used to decompose the task.
-            template (TextPrompt): The prompt template to decompose
-                task. If not provided, the default template will be used.
+            prompt (str, optional): A prompt to decompose the task. If not
+                provided, the default prompt will be used.
             task_parser (Callable[[str, str], List[Task]], optional): A
                 function to extract Task from response. If not provided,
                 the default parse_response will be used.
@@ -212,7 +216,7 @@ class Task(BaseModel):
         """
 
         role_name = agent.role_name
-        content = template.format(
+        content = prompt or TASK_DECOMPOSE_PROMPT.format(
             role_name=role_name,
             content=self.content,
         )
@@ -221,6 +225,8 @@ class Task(BaseModel):
         )
         response = agent.step(msg)
         tasks = task_parser(response.msg.content, self.id)
+        for task in tasks:
+            task.additional_info = self.additional_info
         return tasks
 
     def compose(
@@ -248,6 +254,7 @@ class Task(BaseModel):
         content = template.format(
             role_name=role_name,
             content=self.content,
+            additional_info=self.additional_info,
             other_results=sub_tasks_result,
         )
         msg = BaseMessage.make_user_message(

camel/tasks/task_prompt.py

@@ -39,6 +39,10 @@ The root task is:
 
 {content}
 
+The additional information of the task is:
+
+{additional_info}
+
 The related tasks result and status:
 
 {other_results}

camel/utils/commons.py

@@ -381,10 +381,17 @@ def json_to_function_code(json_obj: Dict) -> str:
     docstring_args = []
     return_keys = []
 
+    prop_to_python = {
+        'string': 'str',
+        'number': 'float',
+        'integer': 'int',
+        'boolean': 'bool',
+    }
+
     for prop in required:
         description = properties[prop]['description']
         prop_type = properties[prop]['type']
-        python_type = 'str' if prop_type == 'string' else prop_type
+        python_type = prop_to_python.get(prop_type, prop_type)
         args.append(f"{prop}: {python_type}")
         docstring_args.append(
             f"        {prop} ({python_type}): {description}."

camel/workforce/__init__.py

@@ -12,12 +12,12 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
-from .base import BaseNode
-from .manager_node import ManagerNode
-from .worker_node import WorkerNode
+from .role_playing_worker import RolePlayingWorker
+from .single_agent_worker import SingleAgentWorker
+from .workforce import Workforce
 
 __all__ = [
-    "BaseNode",
-    "WorkerNode",
-    "ManagerNode",
+    "Workforce",
+    "SingleAgentWorker",
+    "RolePlayingWorker",
 ]

camel/workforce/base.py

@@ -15,36 +15,40 @@ from abc import ABC, abstractmethod
 from typing import Any
 
 from camel.workforce.task_channel import TaskChannel
+from camel.workforce.utils import check_if_running
 
 
 class BaseNode(ABC):
     def __init__(self, description: str) -> None:
         self.node_id = str(id(self))
         self.description = description
-        # every node is initialized to use its own channel
         self._channel: TaskChannel = TaskChannel()
         self._running = False
 
+    @check_if_running(False)
     def reset(self, *args: Any, **kwargs: Any) -> Any:
         """Resets the node to its initial state."""
-        raise NotImplementedError()
+        self._channel = TaskChannel()
+        self._running = False
 
     @abstractmethod
     def set_channel(self, channel: TaskChannel):
         r"""Sets the channel for the node."""
+        pass
 
     @abstractmethod
     async def _listen_to_channel(self):
         r"""Listens to the channel and handle tasks. This method should be
         the main loop for the node.
         """
+        pass
 
     @abstractmethod
     async def start(self):
         r"""Start the node."""
+        pass
 
     @abstractmethod
     def stop(self):
-        r"""
-        Stop the node.
-        """
+        r"""Stop the node."""
+        pass