camel-ai 0.1.5.9__py3-none-any.whl → 0.1.6.2__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.1.5.9'
+__version__ = '0.1.6.2'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -15,8 +15,18 @@ from __future__ import annotations
 
 import json
 from collections import defaultdict
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union,
+)
+
+from pydantic import BaseModel
 
 from camel.agents.base import BaseAgent
 from camel.configs import ChatGPTConfig
@@ -37,7 +47,13 @@ from camel.types import (
     OpenAIBackendRole,
     RoleType,
 )
-from camel.utils import get_model_encoding
+from camel.utils import (
+    Constants,
+    func_string_to_callable,
+    get_model_encoding,
+    get_pydantic_object_schema,
+    json_to_function_code,
+)
 
 if TYPE_CHECKING:
     from openai import Stream
@@ -45,9 +61,19 @@ if TYPE_CHECKING:
     from camel.terminators import ResponseTerminator
     from camel.toolkits import OpenAIFunction
 
+# AgentOps decorator setting
+try:
+    import os
+
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
 
-@dataclass(frozen=True)
-class FunctionCallingRecord:
+
+class FunctionCallingRecord(BaseModel):
     r"""Historical records of functions called in the conversation.
 
     Attributes:
@@ -67,14 +93,17 @@ class FunctionCallingRecord:
         Returns:
             str: Modified string to represent the function calling.
         """
-
         return (
             f"Function Execution: {self.func_name}\n"
             f"\tArgs: {self.args}\n"
             f"\tResult: {self.result}"
         )
 
+    def as_dict(self) -> dict[str, Any]:
+        return self.model_dump()
+
 
+@track_agent(name="ChatAgent")
 class ChatAgent(BaseAgent):
     r"""Class for managing conversations of CAMEL Chat Agents.
 
@@ -128,7 +157,7 @@ class ChatAgent(BaseAgent):
             else ModelFactory.create(
                 model_platform=ModelPlatformType.OPENAI,
                 model_type=ModelType.GPT_4O_MINI,
-                model_config_dict=ChatGPTConfig().__dict__,
+                model_config_dict=ChatGPTConfig().as_dict(),
                 api_key=self._api_key,
             )
         )
@@ -209,7 +238,9 @@ class ChatAgent(BaseAgent):
                 messages.
             role (OpenAIBackendRole): The backend role type.
         """
-        self.memory.write_record(MemoryRecord(message, role))
+        self.memory.write_record(
+            MemoryRecord(message=message, role_at_backend=role)
+        )
 
     def set_output_language(self, output_language: str) -> BaseMessage:
         r"""Sets the output language for the system message. This method
@@ -268,7 +299,8 @@ class ChatAgent(BaseAgent):
         message.
         """
         system_record = MemoryRecord(
-            self.system_message, OpenAIBackendRole.SYSTEM
+            message=self.system_message,
+            role_at_backend=OpenAIBackendRole.SYSTEM,
         )
         self.memory.clear()
         self.memory.write_record(system_record)
@@ -287,6 +319,7 @@ class ChatAgent(BaseAgent):
     def step(
         self,
         input_message: BaseMessage,
+        output_schema: Optional[BaseModel] = None,
     ) -> ChatAgentResponse:
         r"""Performs a single step in the chat session by generating a response
         to the input message.
@@ -297,6 +330,10 @@ class ChatAgent(BaseAgent):
                 either `user` or `assistant` but it will be set to `user`
                 anyway since for the self agent any incoming message is
                 external.
+            output_schema (Optional[BaseModel]): An optional pydantic model
+                that includes value types and field descriptions used to
+                generate a structured response by LLM. This schema helps
+                in defining the expected output format.
 
         Returns:
             ChatAgentResponse: A struct containing the output messages,
@@ -310,7 +347,7 @@ class ChatAgent(BaseAgent):
         tool_calls: List[FunctionCallingRecord] = []
         while True:
             # Format messages and get the token number
-            openai_messages: list[OpenAIMessage] | None
+            openai_messages: Optional[List[OpenAIMessage]]
 
             try:
                 openai_messages, num_tokens = self.memory.get_context()
@@ -318,6 +355,15 @@ class ChatAgent(BaseAgent):
                 return self.step_token_exceed(
                     e.args[1], tool_calls, "max_tokens_exceeded"
                 )
+            # use structed output response without tools
+            # If the user provides the output_schema parameter and does not
+            # specify the use of tools, then in the model config of the
+            # chatgent, call the model specified by tools with
+            # return_json_response of OpenAIFunction format, and return a
+            # structured response with the user-specified output schema.
+            if output_schema is not None and len(self.func_dict) == 0:
+                self._add_output_schema_to_tool_list(output_schema)
+
             (
                 response,
                 output_messages,
@@ -333,9 +379,8 @@ class ChatAgent(BaseAgent):
             ):
                 # Tools added for function calling and not in stream mode
 
-                # Do function calling
-                func_assistant_msg, func_result_msg, func_record = (
-                    self.step_tool_call(response)
+                tool_calls, func_assistant_msg, func_result_msg = (
+                    self._add_tools_for_func_call(response, tool_calls)
                 )
 
                 # Update the messages
@@ -344,11 +389,44 @@ class ChatAgent(BaseAgent):
                 )
                 self.update_memory(func_result_msg, OpenAIBackendRole.FUNCTION)
 
-                # Record the function calling
-                tool_calls.append(func_record)
-
             else:
-                # Function calling disabled or not a function calling
+                # If the user specifies tools, it is necessary to wait for the
+                # model to complete all tools' calls. Finally, use the
+                # generated response as the input for the structure,
+                # simultaneously calling the return_json_response function.
+                # Call the model again with return_json_response in the format
+                # of OpenAIFunction as the last tool, returning a structured
+                # response with the user-specified output schema.
+                if output_schema is not None and all(
+                    record.func_name
+                    != Constants.FUNC_NAME_FOR_STRUCTURE_OUTPUT
+                    for record in tool_calls
+                ):
+                    self._add_output_schema_to_tool_list(output_schema)
+
+                    (
+                        response,
+                        output_messages,
+                        finish_reasons,
+                        usage_dict,
+                        response_id,
+                    ) = self._step_model_response(openai_messages, num_tokens)
+
+                    if isinstance(response, ChatCompletion):
+                        # Tools added for function calling and not in stream
+                        # mode
+                        tool_calls, func_assistant_msg, func_result_msg = (
+                            self._add_tools_for_func_call(response, tool_calls)
+                        )
+
+                        # Update the messages
+                        self.update_memory(
+                            func_assistant_msg, OpenAIBackendRole.ASSISTANT
+                        )
+                        self.update_memory(
+                            func_result_msg, OpenAIBackendRole.FUNCTION
+                        )
+
                 info = self._step_get_info(
                     output_messages,
                     finish_reasons,
@@ -359,20 +437,34 @@ class ChatAgent(BaseAgent):
                 )
                 break
 
-        return ChatAgentResponse(output_messages, self.terminated, info)
+        # if use structure response, set structure result as content of
+        # BaseMessage
+        if output_schema and self.model_type.is_openai:
+            for base_message_item in output_messages:
+                base_message_item.content = str(info['tool_calls'][-1].result)
+
+        return ChatAgentResponse(
+            msgs=output_messages, terminated=self.terminated, info=info
+        )
 
     async def step_async(
         self,
         input_message: BaseMessage,
+        output_schema: Optional[BaseModel] = None,
     ) -> ChatAgentResponse:
         r"""Performs a single step in the chat session by generating a response
         to the input message. This agent step can call async function calls.
 
         Args:
             input_message (BaseMessage): The input message to the agent.
-            Its `role` field that specifies the role at backend may be either
-            `user` or `assistant` but it will be set to `user` anyway since
-            for the self agent any incoming message is external.
+                Its `role` field that specifies the role at backend may be
+                either `user` or `assistant` but it will be set to `user`
+                anyway since for the self agent any incoming message is
+                external.
+            output_schema (Optional[BaseModel]): An optional pydantic model
+                that includes value types and field descriptions used to
+                generate a structured response by LLM. This schema helps
+                in defining the expected output format.
 
         Returns:
             ChatAgentResponse: A struct containing the output messages,
@@ -386,7 +478,7 @@ class ChatAgent(BaseAgent):
         tool_calls: List[FunctionCallingRecord] = []
         while True:
             # Format messages and get the token number
-            openai_messages: list[OpenAIMessage] | None
+            openai_messages: Optional[List[OpenAIMessage]]
 
             try:
                 openai_messages, num_tokens = self.memory.get_context()
@@ -394,6 +486,9 @@ class ChatAgent(BaseAgent):
                 return self.step_token_exceed(
                     e.args[1], tool_calls, "max_tokens_exceeded"
                 )
+            if output_schema is not None:
+                self._add_output_schema_to_tool_list(output_schema)
+
             (
                 response,
                 output_messages,
@@ -426,6 +521,37 @@ class ChatAgent(BaseAgent):
                 tool_calls.append(func_record)
 
             else:
+                # use structed output response without tools
+                if output_schema is not None and all(
+                    record.func_name
+                    != Constants.FUNC_NAME_FOR_STRUCTURE_OUTPUT
+                    for record in tool_calls
+                ):
+                    self._add_output_schema_to_tool_list(output_schema)
+
+                    (
+                        response,
+                        output_messages,
+                        finish_reasons,
+                        usage_dict,
+                        response_id,
+                    ) = self._step_model_response(openai_messages, num_tokens)
+
+                    if isinstance(response, ChatCompletion):
+                        # Tools added for function calling and not in stream
+                        # mode
+                        tool_calls, func_assistant_msg, func_result_msg = (
+                            self._add_tools_for_func_call(response, tool_calls)
+                        )
+
+                        # Update the messages
+                        self.update_memory(
+                            func_assistant_msg, OpenAIBackendRole.ASSISTANT
+                        )
+                        self.update_memory(
+                            func_result_msg, OpenAIBackendRole.FUNCTION
+                        )
+
                 # Function calling disabled or not a function calling
                 info = self._step_get_info(
                     output_messages,
@@ -437,17 +563,100 @@ class ChatAgent(BaseAgent):
                 )
                 break
 
-        return ChatAgentResponse(output_messages, self.terminated, info)
+        # if use structure response, set structure result as content of
+        # BaseMessage
+        if output_schema and self.model_type.is_openai:
+            for base_message_item in output_messages:
+                base_message_item.content = str(info['tool_calls'][0].result)
+
+        return ChatAgentResponse(
+            msgs=output_messages, terminated=self.terminated, info=info
+        )
+
+    def _add_tools_for_func_call(
+        self,
+        response: ChatCompletion,
+        tool_calls: List[FunctionCallingRecord],
+    ) -> tuple[
+        List[FunctionCallingRecord],
+        FunctionCallingMessage,
+        FunctionCallingMessage,
+    ]:
+        r"""
+        Handles adding tools for function calls based on the response.
+        This method processes a function call within the chat completion
+        response, and records the function call in the provided
+        list of tool calls.
+        Args:
+            response (ChatCompletion): The response object from the chat
+                completion.
+            tool_calls (List[FunctionCallingRecord]): The list to record
+                function calls.
+        Returns:
+            tuple: A tuple containing:
+                - List[FunctionCallingRecord]: The updated list of function
+                  call records.
+                - FunctionCallingMessage: The assistant's message regarding the
+                  function call.
+                - FunctionCallingMessage: The result message of the function
+                  call.
+        """
+
+        # Perform function calling
+        func_assistant_msg, func_result_msg, func_record = self.step_tool_call(
+            response
+        )
+
+        # Record the function call in the list of tool calls
+        tool_calls.append(func_record)
+
+        # Return updated tool calls list, assistant's message, and function
+        # result message
+        return tool_calls, func_assistant_msg, func_result_msg
+
+    def _add_output_schema_to_tool_list(self, output_schema: BaseModel):
+        r"""Handles the structured output response for OpenAI.
+        This method processes the given output schema and integrates the
+        resulting function into the tools for the OpenAI model configuration.
+        Args:
+            output_schema (BaseModel): The schema representing the expected
+                output structure.
+        """
+        from camel.toolkits import OpenAIFunction
+
+        # step 1 extract the output_schema info as json.
+        schema_json = get_pydantic_object_schema(output_schema)
+
+        # step 2 convert output schema json as callable string
+        func_str = json_to_function_code(schema_json)
+
+        # step 3 get callable function from string
+        func_callable = func_string_to_callable(func_str)
+
+        # step 4 add return_json_func into tools
+        func = OpenAIFunction(func_callable)
+        tools = [func]
+        self.func_dict[func.get_function_name()] = func.func
+        if self.model_type.is_openai:
+            self.model_backend.model_config_dict = ChatGPTConfig(
+                tools=tools
+            ).as_dict()
+        elif self.model_type.is_gemini:
+            from camel.configs.gemini_config import GeminiConfig
+
+            self.model_backend.model_config_dict = GeminiConfig(
+                tools=tools
+            ).as_dict()
 
     def _step_model_response(
         self,
-        openai_messages: list[OpenAIMessage],
+        openai_messages: List[OpenAIMessage],
         num_tokens: int,
     ) -> tuple[
-        ChatCompletion | Stream[ChatCompletionChunk],
-        list[BaseMessage],
-        list[str],
-        dict[str, int],
+        Union[ChatCompletion, Stream],
+        List[BaseMessage],
+        List[str],
+        Dict[str, int],
         str,
     ]:
         r"""Internal function for agent step model response."""
@@ -617,9 +826,9 @@ class ChatAgent(BaseAgent):
         )
 
         return ChatAgentResponse(
-            output_messages,
-            self.terminated,
-            info,
+            msgs=output_messages,
+            terminated=self.terminated,
+            info=info,
         )
 
     def step_tool_call(
@@ -676,7 +885,9 @@ class ChatAgent(BaseAgent):
         )
 
         # Record information about this function call
-        func_record = FunctionCallingRecord(func_name, args, result)
+        func_record = FunctionCallingRecord(
+            func_name=func_name, args=args, result=result
+        )
         return assist_msg, func_msg, func_record
 
     async def step_tool_call_async(
@@ -735,7 +946,9 @@ class ChatAgent(BaseAgent):
         )
 
         # Record information about this function call
-        func_record = FunctionCallingRecord(func_name, args, result)
+        func_record = FunctionCallingRecord(
+            func_name=func_name, args=args, result=result
+        )
         return assist_msg, func_msg, func_record
 
     def get_usage_dict(

camel/agents/critic_agent.py

@@ -24,7 +24,19 @@ from camel.models import BaseModelBackend
 from camel.responses import ChatAgentResponse
 from camel.utils import get_first_int, print_text_animated
 
+# AgentOps decorator setting
+try:
+    import os
 
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
+@track_agent(name="CriticAgent")
 class CriticAgent(ChatAgent):
     r"""A class for the critic agent that assists in selecting an option.
 
@@ -184,4 +196,8 @@ class CriticAgent(ChatAgent):
         output_msg = meta_chat_message.create_new_instance(option)
 
         # TODO: The return `info` can be improved.
-        return ChatAgentResponse([output_msg], terminated=False, info={})
+        return ChatAgentResponse(
+            msgs=[output_msg],
+            terminated=False,
+            info={},
+        )

camel/agents/deductive_reasoner_agent.py

@@ -20,7 +20,19 @@ from camel.models import BaseModelBackend
 from camel.prompts import TextPrompt
 from camel.types import RoleType
 
+# AgentOps decorator setting
+try:
+    import os
 
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
+@track_agent(name="DeductiveReasonerAgent")
 class DeductiveReasonerAgent(ChatAgent):
     r"""An agent responsible for deductive reasoning. Model of deductive
     reasoning:

camel/agents/embodied_agent.py

@@ -27,7 +27,19 @@ from camel.models import BaseModelBackend
 from camel.responses import ChatAgentResponse
 from camel.utils import print_text_animated
 
+# AgentOps decorator setting
+try:
+    import os
 
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
+@track_agent(name="EmbodiedAgent")
 class EmbodiedAgent(ChatAgent):
     r"""Class for managing conversations of CAMEL Embodied Agents.
 
@@ -120,10 +132,8 @@ class EmbodiedAgent(ChatAgent):
         else:
             return []
 
-    def step(
-        self,
-        input_message: BaseMessage,
-    ) -> ChatAgentResponse:
+    # ruff: noqa: E501
+    def step(self, input_message: BaseMessage) -> ChatAgentResponse:  # type: ignore[override]
         r"""Performs a step in the conversation.
 
         Args:
@@ -184,4 +194,8 @@ class EmbodiedAgent(ChatAgent):
             input_message.meta_dict,
             content,
         )
-        return ChatAgentResponse([message], response.terminated, response.info)
+        return ChatAgentResponse(
+            msgs=[message],
+            terminated=response.terminated,
+            info=response.info,
+        )

camel/agents/knowledge_graph_agent.py

@@ -29,6 +29,18 @@ from camel.storages.graph_storages.graph_element import (
 )
 from camel.types import RoleType
 
+# AgentOps decorator setting
+try:
+    import os
+
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
 text_prompt = """
 You are tasked with extracting nodes and relationships from given content and 
 structures them into Node and Relationship objects. Here's the outline of what 
@@ -97,6 +109,7 @@ into Node and Relationship objects.
 """
 
 
+@track_agent(name="KnowledgeGraphAgent")
 class KnowledgeGraphAgent(ChatAgent):
     r"""An agent that can extract node and relationship information for
     different entities from given `Element` content.
@@ -224,7 +237,7 @@ class KnowledgeGraphAgent(ChatAgent):
             id, type = match.groups()
             properties = {'source': 'agent_created'}
             if id not in nodes:
-                node = Node(id, type, properties)
+                node = Node(id=id, type=type, properties=properties)
                 if self._validate_node(node):
                     nodes[id] = node
 
@@ -235,8 +248,14 @@ class KnowledgeGraphAgent(ChatAgent):
             if subj_id in nodes and obj_id in nodes:
                 subj = nodes[subj_id]
                 obj = nodes[obj_id]
-                relationship = Relationship(subj, obj, rel_type, properties)
+                relationship = Relationship(
+                    subj=subj, obj=obj, type=rel_type, properties=properties
+                )
                 if self._validate_relationship(relationship):
                     relationships.append(relationship)
 
-        return GraphElement(list(nodes.values()), relationships, self.element)
+        return GraphElement(
+            nodes=list(nodes.values()),
+            relationships=relationships,
+            source=self.element,
+        )

camel/agents/role_assignment_agent.py

@@ -20,7 +20,19 @@ from camel.models import BaseModelBackend
 from camel.prompts import TextPrompt
 from camel.types import RoleType
 
+# AgentOps decorator setting
+try:
+    import os
 
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
+@track_agent(name="RoleAssignmentAgent")
 class RoleAssignmentAgent(ChatAgent):
     r"""An agent that generates role names based on the task prompt.
 

camel/agents/search_agent.py

@@ -20,7 +20,19 @@ from camel.prompts import TextPrompt
 from camel.types import RoleType
 from camel.utils import create_chunks
 
+# AgentOps decorator setting
+try:
+    import os
 
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
+@track_agent(name="SearchAgent")
 class SearchAgent(ChatAgent):
     r"""An agent that summarizes text based on a query and evaluates the
     relevance of an answer.

camel/agents/task_agent.py

@@ -20,7 +20,19 @@ from camel.prompts import PromptTemplateGenerator, TextPrompt
 from camel.types import RoleType, TaskType
 from camel.utils import get_task_list
 
+# AgentOps decorator setting
+try:
+    import os
 
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
+@track_agent(name="TaskSpecifyAgent")
 class TaskSpecifyAgent(ChatAgent):
     r"""An agent that specifies a given task prompt by prompting the user to
     provide more details.
@@ -115,6 +127,7 @@ class TaskSpecifyAgent(ChatAgent):
         return TextPrompt(specified_task_msg.content)
 
 
+@track_agent(name="TaskPlannerAgent")
 class TaskPlannerAgent(ChatAgent):
     r"""An agent that helps divide a task into subtasks based on the input
     task prompt.
@@ -184,6 +197,7 @@ class TaskPlannerAgent(ChatAgent):
         return TextPrompt(sub_tasks_msg.content)
 
 
+@track_agent(name="TaskCreationAgent")
 class TaskCreationAgent(ChatAgent):
     r"""An agent that helps create new tasks based on the objective
     and last completed task. Compared to :obj:`TaskPlannerAgent`,
@@ -298,6 +312,7 @@ Be concrete.
         return get_task_list(sub_tasks_msg.content)
 
 
+@track_agent(name="TaskPrioritizationAgent")
 class TaskPrioritizationAgent(ChatAgent):
     r"""An agent that helps re-prioritize the task list and
     returns numbered prioritized list. Modified from