camel-ai 0.2.22__py3-none-any.whl → 0.2.23__py3-none-any.whl

camel/agents/chat_agent.py

@@ -15,8 +15,7 @@ from __future__ import annotations
 
 import json
 import logging
-import re
-import uuid
+import textwrap
 from collections import defaultdict
 from typing import (
     TYPE_CHECKING,
@@ -25,15 +24,25 @@ from typing import (
     Dict,
     List,
     Optional,
-    Tuple,
+    Set,
     Type,
     Union,
 )
 
-from openai.types.chat import ChatCompletionMessageToolCall
-from openai.types.chat.chat_completion_message_tool_call import Function
+from openai import (
+    AsyncStream,
+    Stream,
+)
 from pydantic import BaseModel, ValidationError
 
+from camel.agents._types import ModelResponse, ToolCallRequest
+from camel.agents._utils import (
+    convert_to_function_tool,
+    convert_to_schema,
+    get_info_dict,
+    handle_logprobs,
+    safe_model_dump,
+)
 from camel.agents.base import BaseAgent
 from camel.memories import (
     AgentMemory,
@@ -48,7 +57,9 @@ from camel.models import (
     ModelManager,
     ModelProcessingError,
 )
+from camel.prompts import TextPrompt
 from camel.responses import ChatAgentResponse
+from camel.toolkits import FunctionTool
 from camel.types import (
     ChatCompletion,
     ChatCompletionChunk,
@@ -57,19 +68,11 @@ from camel.types import (
     OpenAIBackendRole,
     RoleType,
 )
-from camel.utils import (
-    func_string_to_callable,
-    generate_prompt_for_structured_output,
-    get_model_encoding,
-    get_pydantic_object_schema,
-    json_to_function_code,
-)
+from camel.types.agents import ToolCallingRecord
+from camel.utils import get_model_encoding
 
 if TYPE_CHECKING:
-    from openai import Stream
-
     from camel.terminators import ResponseTerminator
-    from camel.toolkits import FunctionTool
 
 
 logger = logging.getLogger(__name__)
@@ -86,41 +89,15 @@ except (ImportError, AttributeError):
     from camel.utils import track_agent
 
 
-class ToolCallingRecord(BaseModel):
-    r"""Historical records of tools called in the conversation.
-
-    Attributes:
-        tool_name (str): The name of the tool being called.
-        args (Dict[str, Any]): The dictionary of arguments passed to
-            the tools.
-        result (Any): The execution result of calling this tool.
-        tool_call_id (str): The ID of the tool call, if available.
-    """
-
-    tool_name: str
-    args: Dict[str, Any]
-    result: Any
-    tool_call_id: str
-
-    def __str__(self) -> str:
-        r"""Overridden version of the string function.
-
-        Returns:
-            str: Modified string to represent the tool calling.
-        """
-        return (
-            f"Tool Execution: {self.tool_name}\n"
-            f"\tArgs: {self.args}\n"
-            f"\tResult: {self.result}\n"
-        )
-
-    def as_dict(self) -> dict[str, Any]:
-        r"""Returns the function calling record as a dictionary.
-
-        Returns:
-            dict[str, Any]: The function calling record as a dictionary.
+SIMPLE_FORMAT_PROMPT = TextPrompt(
+    textwrap.dedent(
+        """\
+        Please format the following content:
+        
+        {content}
         """
-        return self.model_dump()
+    )
+)
 
 
 @track_agent(name="ChatAgent")
@@ -148,11 +125,12 @@ class ChatAgent(BaseAgent):
         tools (Optional[List[Union[FunctionTool, Callable]]], optional): List
             of available :obj:`FunctionTool` or :obj:`Callable`. (default:
             :obj:`None`)
-        external_tools (Optional[List[Union[FunctionTool, Callable]]],
-            optional): List of external tools (:obj:`FunctionTool` or or
-            :obj:`Callable`) bind to one chat agent. When these tools are
-            called, the agent will directly return the request instead of
-            processing it. (default: :obj:`None`)
+        external_tools (Optional[List[Union[FunctionTool, Callable,
+            Dict[str, Any]]]], optional): List of external tools
+            (:obj:`FunctionTool` or :obj:`Callable` or :obj:`Dict[str, Any]`)
+            bind to one chat agent. When these tools are called, the agent will
+            directly return the request instead of processing it.
+            (default: :obj:`None`)
         response_terminators (List[ResponseTerminator], optional): List of
             :obj:`ResponseTerminator` bind to one chat agent.
             (default: :obj:`None`)
@@ -173,265 +151,164 @@ class ChatAgent(BaseAgent):
         token_limit: Optional[int] = None,
         output_language: Optional[str] = None,
         tools: Optional[List[Union[FunctionTool, Callable]]] = None,
-        external_tools: Optional[List[Union[FunctionTool, Callable]]] = None,
+        external_tools: Optional[
+            List[Union[FunctionTool, Callable, Dict[str, Any]]]
+        ] = None,
         response_terminators: Optional[List[ResponseTerminator]] = None,
         scheduling_strategy: str = "round_robin",
         single_iteration: bool = False,
     ) -> None:
-        # Initialize the system message, converting string to BaseMessage if needed
-        if isinstance(system_message, str):
-            system_message = BaseMessage.make_assistant_message(
-                role_name='Assistant', content=system_message
-            )
-
-        self.orig_sys_message: Optional[BaseMessage] = system_message
-        self._system_message: Optional[BaseMessage] = system_message
-        self.role_name: str = (
-            getattr(system_message, 'role_name', None) or "assistant"
-        )
-        self.role_type: RoleType = (
-            getattr(system_message, 'role_type', None) or RoleType.ASSISTANT
-        )
+        # Set up model backend
         self.model_backend = ModelManager(
-            model
-            if model is not None
-            else ModelFactory.create(
-                model_platform=ModelPlatformType.DEFAULT,
-                model_type=ModelType.DEFAULT,
+            (
+                model
+                if model is not None
+                else ModelFactory.create(
+                    model_platform=ModelPlatformType.DEFAULT,
+                    model_type=ModelType.DEFAULT,
+                )
             ),
             scheduling_strategy=scheduling_strategy,
         )
         self.model_type = self.model_backend.model_type
 
-        # Initialize tools
-        self.tools: List[FunctionTool] = (
-            self._initialize_tools(tools) if tools else []
-        )
-        self.external_tools: List[FunctionTool] = (
-            self._initialize_tools(external_tools) if external_tools else []
-        )
-        self.external_tool_names: List[str] = [
-            tool.get_function_name() for tool in self.external_tools
-        ]
-        self.all_tools = self.tools + self.external_tools or []
-
-        # Create tool dictionaries and configure backend tools if necessary
-        self.tool_dict = {
-            tool.get_function_name(): tool for tool in self.all_tools
-        }
-
-        # If the user set tools from `ChatAgent`, it will override the
-        # configured tools in `BaseModelBackend`.
-        if self.all_tools:
-            logger.warning(
-                "Overriding the configured tools in `BaseModelBackend` with the tools from `ChatAgent`."
-            )
-            tool_schema_list = [
-                tool.get_openai_tool_schema() for tool in self.all_tools
-            ]
-            self.model_backend.model_config_dict['tools'] = tool_schema_list
-
-        self.model_token_limit = token_limit or self.model_backend.token_limit
+        # Set up memory
         context_creator = ScoreBasedContextCreator(
             self.model_backend.token_counter,
-            self.model_token_limit,
+            token_limit or self.model_backend.token_limit,
         )
         self.memory: AgentMemory = memory or ChatHistoryMemory(
             context_creator, window_size=message_window_size
         )
 
-        self.output_language: Optional[str] = output_language
-        if self.output_language is not None:
-            self.set_output_language(self.output_language)
-
-        self.terminated: bool = False
-        self.response_terminators = response_terminators or []
+        # Set up system message and initialize messages
+        self._original_system_message = (
+            BaseMessage.make_assistant_message(
+                role_name="Assistant", content=system_message
+            )
+            if isinstance(system_message, str)
+            else system_message
+        )
+        self._output_language = output_language
+        self._system_message = (
+            self._generate_system_message_for_output_language()
+        )
         self.init_messages()
-        self.tool_prompt_added = False
-        self.single_iteration = single_iteration
 
-    def _initialize_tools(
-        self, tools: List[Union[FunctionTool, Callable]]
-    ) -> List[FunctionTool]:
-        r"""Helper method to initialize tools as FunctionTool instances."""
-        from camel.toolkits import FunctionTool
-
-        func_tools = []
-        for tool in tools:
-            if not isinstance(tool, FunctionTool):
-                tool = FunctionTool(tool)
-            func_tools.append(tool)
-        return func_tools
-
-    def add_tool(
-        self, tool: Union[FunctionTool, Callable], is_external: bool = False
-    ) -> None:
-        r"""Add a tool to the agent, specifying if it's an external tool."""
-        # Initialize the tool
-        initialized_tool = self._initialize_tools([tool])
-
-        # Update tools or external tools based on is_external flag
-        if is_external:
-            self.external_tools = self.external_tools + initialized_tool
-            self.external_tool_names.extend(
-                tool.get_function_name() for tool in initialized_tool
-            )
-        else:
-            self.tools = self.tools + initialized_tool
+        # Set up role name and role type
+        self.role_name: str = (
+            getattr(self.system_message, "role_name", None) or "assistant"
+        )
+        self.role_type: RoleType = (
+            getattr(self.system_message, "role_type", None)
+            or RoleType.ASSISTANT
+        )
 
-        # Rebuild all_tools, and tool_dict
-        self.all_tools = self.tools + self.external_tools
-        self.tool_dict = {
-            tool.get_function_name(): tool for tool in self.all_tools
+        # Set up tools
+        self._internal_tools = {
+            tool.get_function_name(): tool
+            for tool in [
+                convert_to_function_tool(tool) for tool in (tools or [])
+            ]
         }
 
-        tool_schema_list = [
-            tool.get_openai_tool_schema() for tool in self.all_tools
-        ]
-        self.model_backend.model_config_dict['tools'] = tool_schema_list
+        self._external_tool_schemas = {
+            tool_schema["function"]["name"]: tool_schema
+            for tool_schema in [
+                convert_to_schema(tool) for tool in (external_tools or [])
+            ]
+        }
 
-    def remove_tool(self, tool_name: str, is_external: bool = False) -> bool:
-        r"""Remove a tool by name, specifying if it's an external tool."""
-        tool_list = self.external_tools if is_external else self.tools
-        if not tool_list:
-            return False
+        # Set up other properties
+        self.terminated = False
+        self.response_terminators = response_terminators or []
+        self.single_iteration = single_iteration
 
-        for tool in tool_list:
-            if tool.get_function_name() == tool_name:
-                tool_list.remove(tool)
-                if is_external:
-                    self.external_tool_names.remove(tool_name)
-                # Reinitialize the tool dictionary
-                self.all_tools = (self.tools or []) + (
-                    self.external_tools or []
-                )
-                self.tool_dict = {
-                    tool.get_function_name(): tool for tool in self.all_tools
-                }
-                tool_schema_list = [
-                    tool.get_openai_tool_schema() for tool in self.all_tools
-                ]
-                self.model_backend.model_config_dict['tools'] = (
-                    tool_schema_list
-                )
-                return True
-        return False
+    def reset(self):
+        r"""Resets the :obj:`ChatAgent` to its initial state."""
+        self.terminated = False
+        self.init_messages()
+        for terminator in self.response_terminators:
+            terminator.reset()
 
-    def list_tools(self) -> dict:
-        r"""List all tools, separated into normal and external tools."""
-        normal_tools = [
-            tool.get_function_name() for tool in (self.tools or [])
-        ]
-        external_tools = [
-            tool.get_function_name() for tool in (self.external_tools or [])
-        ]
+    @property
+    def system_message(self) -> Optional[BaseMessage]:
+        r"""Returns the system message for the agent."""
+        return self._system_message
 
-        return {"normal_tools": normal_tools, "external_tools": external_tools}
+    @property
+    def tool_dict(self) -> Dict[str, FunctionTool]:
+        r"""Returns a dictionary of internal tools."""
+        return self._internal_tools
 
-    # ruff: noqa: E501
-    def _generate_tool_prompt(self, tool_schema_list: List[Dict]) -> str:
-        r"""Generates a tool prompt based on the provided tool schema list.
+    @property
+    def output_language(self) -> Optional[str]:
+        r"""Returns the output language for the agent."""
+        return self._output_language
 
-        Args:
-            tool_schema_list (List[Dict]): A list of dictionaries, each
-                containing a tool schema.
+    @output_language.setter
+    def output_language(self, value: str) -> None:
+        r"""Set the output language for the agent.
 
-        Returns:
-            str: A string representing the tool prompt.
+        Note that this will clear the message history.
         """
-        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"""
-    You have access to the following functions:
+        self._output_language = value
+        self._system_message = (
+            self._generate_system_message_for_output_language()
+        )
+        self.init_messages()
 
-    {tool_prompt_str}
+    def _get_full_tool_schemas(self) -> List[Dict[str, Any]]:
+        r"""Returns a list of tool schemas of all tools, including internal
+        and external tools.
+        """
+        return list(self._external_tool_schemas.values()) + [
+            func_tool.get_openai_tool_schema()
+            for func_tool in self._internal_tools.values()
+        ]
 
-    If you choose to call a function ONLY reply in the following format with no
-    prefix or suffix:
+    def _get_external_tool_names(self) -> Set[str]:
+        r"""Returns a set of external tool names."""
+        return set(self._external_tool_schemas.keys())
 
-    <function=example_function_name>{{"example_name": "example_value"}}</function>
+    def add_tool(self, tool: Union[FunctionTool, Callable]) -> None:
+        r"""Add a tool to the agent."""
+        new_tool = convert_to_function_tool(tool)
+        self._internal_tools[new_tool.get_function_name()] = new_tool
 
-    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 add_external_tool(
+        self, tool: Union[FunctionTool, Callable, Dict[str, Any]]
+    ) -> None:
+        new_tool_schema = convert_to_schema(tool)
+        self._external_tool_schemas[new_tool_schema["name"]] = new_tool_schema
 
-    def _parse_tool_response(self, response: str):
-        r"""Parses the tool response to extract the function name and
-        arguments.
+    def remove_tool(self, tool_name: str) -> bool:
+        r"""Remove a tool from the agent by name.
 
         Args:
-            response (str): The response from the model containing the
-                function call.
+            tool_name (str): The name of the tool to remove.
 
         Returns:
-            Optional[Dict[str, Any]]: The parsed function name and arguments
-                if found, otherwise :obj:`None`.
+            bool: Whether the tool was successfully removed.
         """
-        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:
-                logger.error(f"Error parsing function arguments: {error}")
-                return None
-        return None
-
-    def reset(self):
-        r"""Resets the :obj:`ChatAgent` to its initial state."""
-        self.terminated = False
-        self.init_messages()
-        for terminator in self.response_terminators:
-            terminator.reset()
-
-    @property
-    def system_message(self) -> Optional[BaseMessage]:
-        r"""The getter method for the property :obj:`system_message`.
-
-        Returns:
-            Optional[BaseMessage]: The system message of this agent if set,
-                else :obj:`None`.
-        """
-        return self._system_message
+        if tool_name in self._internal_tools:
+            del self._internal_tools[tool_name]
+            return True
+        return False
 
-    @system_message.setter
-    def system_message(self, message: BaseMessage) -> None:
-        r"""The setter method for the property :obj:`system_message`.
+    def remove_external_tool(self, tool_name: str) -> bool:
+        r"""Remove an external tool from the agent by name.
 
         Args:
-            message (BaseMessage): The message to be set as the
-                new system message of this agent.
-        """
-        self._system_message = message
-
-    def is_tools_added(self) -> bool:
-        r"""Whether tool calling is enabled for this agent.
+            tool_name (str): The name of the tool to remove.
 
         Returns:
-            bool: Whether tool calling is enabled for this agent, determined
-                by whether the dictionary of tools is empty.
+            bool: Whether the tool was successfully removed.
         """
-        return len(self.tool_dict) > 0
+        if tool_name in self._external_tool_schemas:
+            del self._external_tool_schemas[tool_name]
+            return True
+        return False
 
     def update_memory(
         self, message: BaseMessage, role: OpenAIBackendRole
@@ -447,94 +324,41 @@ class ChatAgent(BaseAgent):
             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
-        updates the output language for the system message. The output
-        language determines the language in which the output text should be
-        generated.
+    def _generate_system_message_for_output_language(
+        self,
+    ) -> Optional[BaseMessage]:
+        r"""Generate a new system message with the output language prompt.
 
-        Args:
-            output_language (str): The desired output language.
+        The output language determines the language in which the output text
+        should be generated.
 
         Returns:
-            BaseMessage: The updated system message object.
+            BaseMessage: The new system message.
         """
-        self.output_language = output_language
+        if not self._output_language:
+            return self._original_system_message
+
         language_prompt = (
             "\nRegardless of the input language, "
-            f"you must output text in {output_language}."
+            f"you must output text in {self._output_language}."
         )
-        if self.orig_sys_message is not None:
-            content = self.orig_sys_message.content + language_prompt
-            self._system_message = self.orig_sys_message.create_new_instance(
-                content
-            )
+
+        if self._original_system_message is not None:
+            content = self._original_system_message.content + language_prompt
+            return self._original_system_message.create_new_instance(content)
         else:
-            self._system_message = BaseMessage.make_assistant_message(
+            return BaseMessage.make_assistant_message(
                 role_name="Assistant",
                 content=language_prompt,
             )
 
-        system_record = MemoryRecord(
-            message=self._system_message,
-            role_at_backend=OpenAIBackendRole.SYSTEM,
-        )
-        self.memory.clear()
-        self.memory.write_record(system_record)
-        return self._system_message
-
-    def get_info(
-        self,
-        session_id: Optional[str],
-        usage: Optional[Dict[str, int]],
-        termination_reasons: List[str],
-        num_tokens: int,
-        tool_calls: List[ToolCallingRecord],
-        external_tool_request: Optional[ChatCompletionMessageToolCall] = None,
-    ) -> Dict[str, Any]:
-        r"""Returns a dictionary containing information about the chat session.
-
-        Args:
-            session_id (str, optional): The ID of the chat session.
-            usage (Dict[str, int], optional): Information about the usage of
-                the LLM.
-            termination_reasons (List[str]): The reasons for the termination
-                of the chat session.
-            num_tokens (int): The number of tokens used in the chat session.
-            tool_calls (List[ToolCallingRecord]): The list of function
-                calling records, containing the information of called tools.
-            external_tool_request
-                (Optional[ChatCompletionMessageToolCall], optional):
-                The tool calling request of external tools from the model.
-                These requests are directly returned to the user instead of
-                being processed by the agent automatically.
-                (default: :obj:`None`)
-
-        Returns:
-            Dict[str, Any]: The chat session information.
-        """
-        return {
-            "id": session_id,
-            "usage": usage,
-            "termination_reasons": termination_reasons,
-            "num_tokens": num_tokens,
-            "tool_calls": tool_calls,
-            "external_tool_request": external_tool_request,
-        }
-
     def init_messages(self) -> None:
         r"""Initializes the stored messages list with the current system
         message.
         """
-        if self._system_message is not None:
-            system_record = MemoryRecord(
-                message=self._system_message,
-                role_at_backend=OpenAIBackendRole.SYSTEM,
-            )
-            self.memory.clear()
-            self.memory.write_record(system_record)
-        else:
-            self.memory.clear()
+        self.memory.clear()
+        if self.system_message is not None:
+            self.update_memory(self.system_message, OpenAIBackendRole.SYSTEM)
 
     def record_message(self, message: BaseMessage) -> None:
         r"""Records the externally provided message into the agent memory as if
@@ -547,10 +371,82 @@ class ChatAgent(BaseAgent):
         """
         self.update_memory(message, OpenAIBackendRole.ASSISTANT)
 
+    def _try_format_message(
+        self, message: BaseMessage, response_format: Type[BaseModel]
+    ) -> bool:
+        r"""Try to format the message if needed.
+
+        Returns:
+            bool: Whether the message is formatted successfully (or no format
+                is needed).
+        """
+        if message.parsed:
+            return True
+
+        try:
+            message.parsed = response_format.model_validate_json(
+                message.content
+            )
+            return True
+        except ValidationError:
+            return False
+
+    def _format_response_if_needed(
+        self,
+        response: ModelResponse,
+        response_format: Optional[Type[BaseModel]] = None,
+    ) -> None:
+        r"""Format the response if needed.
+
+        This function won't format the response under the following cases:
+        1. The response format is None (not provided)
+        2. The response is empty
+        """
+        if response_format is None:
+            return
+
+        for message in response.output_messages:
+            if self._try_format_message(message, response_format):
+                continue
+
+            prompt = SIMPLE_FORMAT_PROMPT.format(content=message.content)
+            openai_message: OpenAIMessage = {"role": "user", "content": prompt}
+            # Explicitly set the tools to empty list to avoid calling tools
+            response = self._get_model_response(
+                [openai_message], 0, response_format, []
+            )
+            message.content = response.output_messages[0].content
+            if not self._try_format_message(message, response_format):
+                logger.warning(f"Failed to parse response: {message.content}")
+
+    async def _aformat_response_if_needed(
+        self,
+        response: ModelResponse,
+        response_format: Optional[Type[BaseModel]] = None,
+    ) -> None:
+        r"""Format the response if needed."""
+
+        if response_format is None:
+            return
+
+        for message in response.output_messages:
+            self._try_format_message(message, response_format)
+            if message.parsed:
+                continue
+
+            prompt = SIMPLE_FORMAT_PROMPT.format(content=message.content)
+            openai_message: OpenAIMessage = {"role": "user", "content": prompt}
+            response = await self._aget_model_response(
+                [openai_message], 0, response_format, []
+            )
+            message.content = response.output_messages[0].content
+            self._try_format_message(message, response_format)
+
     def step(
         self,
         input_message: Union[BaseMessage, str],
         response_format: Optional[Type[BaseModel]] = None,
+        reason_params: Optional[Dict[str, Any]] = None,
     ) -> ChatAgentResponse:
         r"""Executes a single step in the chat session, generating a response
         to the input message.
@@ -563,295 +459,116 @@ class ChatAgent(BaseAgent):
                 model defining the expected structure of the response. Used to
                 generate a structured response if provided. (default:
                 :obj:`None`)
+            reason_params (Optional[Dict[str, Any]], optional): A dictionary
+                containing the parameters for the reasoning step.
+                Argument `choices` is the number of choices/candidates to
+                consider.
+                Argument `threshold` is the threshold for the probability of
+                the choices.
+                (default: :obj:`None`)
 
         Returns:
             ChatAgentResponse: Contains output messages, a termination status
                 flag, and session information.
         """
 
-        if (
-            self.model_backend.model_config_dict.get("response_format")
-            and response_format
-        ):
-            logger.warning(
-                f"Overriding the response format with {response_format}."
-            )
-
-        self.original_model_dict = self.model_backend.model_config_dict
-        model_response_format_modified = False
-        if (
-            response_format
-            and self.model_type.support_native_structured_output
-        ):
-            self.model_backend.model_config_dict = (
-                self.original_model_dict.copy()
-            )
-            self.model_backend.model_config_dict["response_format"] = (
-                response_format
-            )
-            model_response_format_modified = True
-
         # Convert input message to BaseMessage if necessary
         if isinstance(input_message, str):
             input_message = BaseMessage.make_user_message(
-                role_name='User', content=input_message
+                role_name="User", content=input_message
             )
 
-        # Handle tool prompt injection if needed
-        if (
-            self.is_tools_added()
-            and not self.model_type.support_native_tool_calling
-            and not self.tool_prompt_added
-        ):
-            self._inject_tool_prompt()
+        # Inject thinking steps
+        input_message = self._update_reasoning(input_message, reason_params)
 
         # Add user input to memory
         self.update_memory(input_message, OpenAIBackendRole.USER)
 
-        try:
-            return self._handle_step(response_format, self.single_iteration)
-        finally:
-            if model_response_format_modified:
-                # Reset model config back to original state
-                self.model_backend.model_config_dict = self.original_model_dict
-
-    def _inject_tool_prompt(self) -> None:
-        r"""Generate and add the tool prompt to memory."""
-        tool_prompt = self._generate_tool_prompt(
-            self.model_backend.model_config_dict["tools"]
-        )
-        tool_msg = BaseMessage.make_assistant_message(
-            role_name="Assistant", content=tool_prompt
-        )
-        self.update_memory(tool_msg, OpenAIBackendRole.SYSTEM)
-        self.tool_prompt_added = True
-
-    def _handle_step(
-        self,
-        response_format: Optional[Type[BaseModel]],
-        single_step: bool,
-    ) -> ChatAgentResponse:
-        r"""Handles a single or multi-step interaction."""
-
-        if (
-            self.model_backend.model_config_dict.get("tool_choice")
-            == "required"
-            and not single_step
-        ):
-            raise ValueError(
-                "`tool_choice` cannot be set to `required` for multi-step"
-                " mode. To proceed, set `single_iteration` to `True`."
-            )
-
-        # Record function calls made during the session
         tool_call_records: List[ToolCallingRecord] = []
-
-        external_tool_request = None
+        external_tool_call_request: Optional[ToolCallRequest] = None
 
         while True:
             try:
                 openai_messages, num_tokens = self.memory.get_context()
             except RuntimeError as e:
-                self.model_backend.model_config_dict = self.original_model_dict
                 return self._step_token_exceed(
                     e.args[1], tool_call_records, "max_tokens_exceeded"
                 )
-
-            # Prompt engineering approach for structured output for non-native tool calling models
-            inject_prompt_for_structured_output = (
-                response_format
-                and not self.model_type.support_native_structured_output
+            # Get response from model backend
+            response = self._get_model_response(
+                openai_messages,
+                num_tokens,
+                response_format,
+                self._get_full_tool_schemas(),
             )
 
-            if inject_prompt_for_structured_output:
-                # update last openai message
-                usr_msg = openai_messages.pop()
-                usr_msg["content"] = generate_prompt_for_structured_output(
-                    response_format,
-                    usr_msg["content"],  # type: ignore [arg-type]
-                )
-                openai_messages.append(usr_msg)
-
-            # Process model response
-            (
-                response,
-                output_messages,
-                finish_reasons,
-                usage_dict,
-                response_id,
-            ) = self._step_model_response(openai_messages, num_tokens)
-
-            # Try to parse structured output to return a Pydantic object
-            if inject_prompt_for_structured_output and isinstance(
-                response, ChatCompletion
-            ):
-                content = response.choices[0].message.content
-                try:
-                    json_content = json.loads(str(content))
-                    output_messages[0].parsed = response_format(**json_content)  # type: ignore [assignment, misc]
-                except json.JSONDecodeError as e:
-                    logger.error(
-                        f"Failed in parsing the output into JSON: {e}"
-                    )
-                    output_messages[0].parsed = None
-                except ValidationError as e:
-                    logger.warning(
-                        "Successfully generating JSON response, "
-                        "but failed in parsing it into Pydantic object :"
-                        f"{e}, return the JSON response in parsed field"
-                    )
-                    output_messages[0].parsed = json_content
-
-            # Finalize on standard response in multi-step mode
-            if self._is_standard_response(response):
+            if self.single_iteration:
                 break
 
-            # Handle tool requests
-            tool_request = self._extract_tool_call(response)
-            if isinstance(response, ChatCompletion) and tool_request:
-                response.choices[0].message.tool_calls = [tool_request]
-                tool_call_records.append(
-                    self._step_tool_call_and_update(response)
-                )
+            if tool_call_request := response.tool_call_request:
+                if tool_call_request.tool_name in self._external_tool_schemas:
+                    external_tool_call_request = tool_call_request
+                    break
 
-                if tool_request.function.name in self.external_tool_names:
-                    external_tool_request = tool_request
-                    info = self._step_get_info(
-                        output_messages,
-                        finish_reasons,
-                        usage_dict,
-                        response_id,
-                        tool_call_records,
-                        num_tokens,
-                        tool_request,
-                    )
-                    self._log_final_output(output_messages)
-                    self.model_backend.model_config_dict = (
-                        self.original_model_dict
-                    )
-                    return ChatAgentResponse(
-                        msgs=output_messages,
-                        terminated=self.terminated,
-                        info=info,
-                    )
-
-            # Single-step mode ends after one iteration
-            if single_step:
-                break
+                tool_call_records.append(self._execute_tool(tool_call_request))
+                continue
 
-        # Optional structured output via function calling
-        if (
-            response_format
-            and not inject_prompt_for_structured_output
-            and self.model_type
-            not in {
-                "gpt-4o",
-                "gpt-4o-mini",
-            }
-        ):
-            (
-                output_messages,
-                finish_reasons,
-                usage_dict,
-                response_id,
-                tool_call,
-                num_tokens,
-            ) = self._structure_output_with_function(response_format)
-            tool_call_records.append(tool_call)
+            break
 
-        # Final info and response
-        info = self._step_get_info(
-            output_messages,
-            finish_reasons,
-            usage_dict,
-            response_id,
-            tool_call_records,
-            num_tokens,
-            external_tool_request,
-        )
-        self._log_final_output(output_messages)
-        self.model_backend.model_config_dict = self.original_model_dict
-        return ChatAgentResponse(
-            msgs=output_messages, terminated=self.terminated, info=info
+        self._format_response_if_needed(response, response_format)
+        self._record_final_output(response.output_messages)
+
+        return self._convert_to_chatagent_response(
+            response, tool_call_records, num_tokens, external_tool_call_request
         )
 
-    def _extract_tool_call(
-        self, response: Any
-    ) -> Optional[ChatCompletionMessageToolCall]:
-        r"""Extract the tool call from the model response, if present.
+    def _update_reasoning(
+        self,
+        input_message: BaseMessage,
+        reason_params: Optional[Dict[str, Any]] = None,
+    ) -> BaseMessage:
+        r"""Updates the input message to include reasoning instructions and
+        adds human interaction capability.
 
         Args:
-            response (Any): The model's response object.
+            input_message (BaseMessage): The message to be updated with
+                reasoning instructions.
+            reason_params (Optional[Dict[str, Any]], optional): Parameters for
+                the reasoning process.
 
         Returns:
-            Optional[ChatCompletionMessageToolCall]: The parsed tool call if
-                present, otherwise None.
+            BaseMessage: The updated message with reasoning instructions.
         """
-        # Check if the response contains tool calls
-        if (
-            self.is_tools_added()
-            and not self.model_type.support_native_tool_calling
-            and "</function>" in response.choices[0].message.content
-        ):
-            parsed_content = self._parse_tool_response(
-                response.choices[0].message.content
-            )
-            if parsed_content:
-                return ChatCompletionMessageToolCall(
-                    id=str(uuid.uuid4()),
-                    function=Function(
-                        arguments=str(parsed_content["arguments"]).replace(
-                            "'", '"'
-                        ),
-                        name=str(parsed_content["function"]),
-                    ),
-                    type="function",
-                )
-        elif (
-            self.is_tools_added()
-            and self.model_type.support_native_tool_calling
-            and response.choices[0].message.tool_calls
-        ):
-            return response.choices[0].message.tool_calls[0]
-
-        # No tool call found
-        return None
-
-    def _is_standard_response(self, response: Any) -> bool:
-        r"""Determine if the provided response is a standard reply without
-        tool calls.
-
-        Args:
-            response (Any): The response object to evaluate.
-
-        Returns:
-            bool: `True` if the response is a standard reply, `False`
-                otherwise.
+        if reason_params is None:
+            return input_message
+        choices = reason_params.get("choices", 3)
+        threshold = reason_params.get("threshold", 0.5)
+
+        input_message.content += f"""First, come up with potential {choices} 
+        choices/candidates. 
+        Next, assign a probability/credibility between 0 and 1 to each choice 
+        (make sure they add up to 1). 
+        Finally, if only one choice has a probability/credibility greater than
+        {threshold}, continue with that choice.
+        Otherwise, call tool `ask_human_via_console` to ask the user to decide 
+        which one to continue with, give user the probability/credibility of 
+        all choices, and the reason for each choice.
         """
-        if not self.is_tools_added():
-            return True
 
-        if not isinstance(response, ChatCompletion):
-            return True
+        # Add tools to agent
+        from camel.toolkits.human_toolkit import HumanToolkit
 
-        if self.model_type.support_native_tool_calling:
-            return not response.choices[0].message.tool_calls
+        human_toolkit = HumanToolkit()
+        self.add_tool(human_toolkit.ask_human_via_console)
 
-        return "</function>" not in str(
-            response.choices[0].message.content or ""
-        )
+        return input_message
 
-    def _log_final_output(self, output_messages: List[BaseMessage]) -> None:
-        r"""Log final messages or warnings about multiple responses."""
-        if len(output_messages) == 1:
-            self.record_message(output_messages[0])
-        else:
-            logger.warning(
-                "Multiple messages returned in `step()`. Record "
-                "selected message manually using `record_message()`."
-            )
+    @property
+    def chat_history(self) -> List[OpenAIMessage]:
+        openai_messages, _ = self.memory.get_context()
+        return openai_messages
 
-    async def step_async(
+    async def astep(
         self,
         input_message: Union[BaseMessage, str],
         response_format: Optional[Type[BaseModel]] = None,
@@ -879,12 +596,13 @@ class ChatAgent(BaseAgent):
         """
         if isinstance(input_message, str):
             input_message = BaseMessage.make_user_message(
-                role_name='User', content=input_message
+                role_name="User", content=input_message
             )
 
         self.update_memory(input_message, OpenAIBackendRole.USER)
 
         tool_call_records: List[ToolCallingRecord] = []
+        external_tool_call_request: Optional[ToolCallRequest] = None
         while True:
             try:
                 openai_messages, num_tokens = self.memory.get_context()
@@ -893,224 +611,146 @@ class ChatAgent(BaseAgent):
                     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 (
-                not self.is_tools_added()
-                or not isinstance(response, ChatCompletion)
-                or not response.choices[0].message.tool_calls
-            ):
+            response = await self._aget_model_response(
+                openai_messages,
+                num_tokens,
+                response_format,
+                self._get_full_tool_schemas(),
+            )
+
+            if self.single_iteration:
                 break
 
-            # Check for external tool call
-            external_tool_request = response.choices[0].message.tool_calls[0]
-            if external_tool_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,
-                    external_tool_request,
-                )
-                return ChatAgentResponse(
-                    msgs=output_messages, terminated=self.terminated, info=info
-                )
+            if tool_call_request := response.tool_call_request:
+                if tool_call_request.tool_name in self._external_tool_schemas:
+                    external_tool_call_request = tool_call_request
+                    break
 
-            # Normal function calling
-            tool_call_records.append(
-                await self._step_tool_call_and_update_async(response)
-            )
+                tool_call_record = await self._aexecute_tool(tool_call_request)
+                tool_call_records.append(tool_call_record)
+                continue
 
-        if (
-            response_format is not None
-            and self.model_type.support_native_tool_calling
-        ):
-            (
-                output_messages,
-                finish_reasons,
-                usage_dict,
-                response_id,
-                tool_call_record,
-                num_tokens,
-            ) = self._structure_output_with_function(response_format)
-            tool_call_records.append(tool_call_record)
+            break
+
+        await self._aformat_response_if_needed(response, response_format)
+        self._record_final_output(response.output_messages)
 
+        return self._convert_to_chatagent_response(
+            response, tool_call_records, num_tokens, external_tool_call_request
+        )
+
+    def _convert_to_chatagent_response(
+        self,
+        response: ModelResponse,
+        tool_call_records: List[ToolCallingRecord],
+        num_tokens: int,
+        external_tool_call_request: Optional[ToolCallRequest],
+    ) -> ChatAgentResponse:
+        r"""Parse the final model response into the chat agent response."""
         info = self._step_get_info(
-            output_messages,
-            finish_reasons,
-            usage_dict,
-            response_id,
+            response.output_messages,
+            response.finish_reasons,
+            response.usage_dict,
+            response.response_id,
             tool_call_records,
             num_tokens,
+            external_tool_call_request,
         )
 
+        return ChatAgentResponse(
+            msgs=response.output_messages,
+            terminated=self.terminated,
+            info=info,
+        )
+
+    def _record_final_output(self, output_messages: List[BaseMessage]) -> None:
+        r"""Log final messages or warnings about multiple responses."""
         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."
+                "Multiple messages returned in `step()`. Record "
+                "selected message manually using `record_message()`."
             )
 
-        return ChatAgentResponse(
-            msgs=output_messages, terminated=self.terminated, info=info
-        )
-
-    def _step_tool_call_and_update(
-        self, response: ChatCompletion
-    ) -> ToolCallingRecord:
-        r"""Processes a function call within the chat completion response,
-        records the function call in the provided list of tool calls and
-        updates the memory of the current agent.
+    def _get_model_response(
+        self,
+        openai_messages: List[OpenAIMessage],
+        num_tokens: int,
+        response_format: Optional[Type[BaseModel]] = None,
+        tool_schemas: Optional[List[Dict[str, Any]]] = None,
+    ) -> ModelResponse:
+        r"""Internal function for agent step model response."""
 
-        Args:
-            response (ChatCompletion): The response object from the chat
-                completion.
+        response = None
+        try:
+            response = self.model_backend.run(
+                openai_messages, response_format, tool_schemas or None
+            )
+        except Exception as exc:
+            logger.error(
+                f"An error occurred while running model "
+                f"{self.model_backend.model_type}, "
+                f"index: {self.model_backend.current_model_index}",
+                exc_info=exc,
+            )
+            error_info = str(exc)
 
-        Returns:
-            ToolCallingRecord: The record of calling the function.
-        """
+        if not response and self.model_backend.num_models > 1:
+            raise ModelProcessingError(
+                "Unable to process messages: none of the provided models "
+                "run succesfully."
+            )
+        elif not response:
+            raise ModelProcessingError(
+                f"Unable to process messages: the only provided model "
+                f"did not run succesfully. Error: {error_info}"
+            )
 
-        # Perform function calling
-        func_assistant_msg, func_result_msg, tool_call_record = (
-            self._step_tool_call(response)
+        logger.info(
+            f"Model {self.model_backend.model_type}, "
+            f"index {self.model_backend.current_model_index}, "
+            f"processed these messages: {openai_messages}"
         )
 
-        # Update the messages
-        self.update_memory(func_assistant_msg, OpenAIBackendRole.ASSISTANT)
-        self.update_memory(func_result_msg, OpenAIBackendRole.FUNCTION)
-
-        return tool_call_record
-
-    async def _step_tool_call_and_update_async(
-        self, response: ChatCompletion
-    ) -> ToolCallingRecord:
-        (
-            func_assistant_msg,
-            func_result_msg,
-            func_record,
-        ) = await self.step_tool_call_async(response)
-
-        self.update_memory(func_assistant_msg, OpenAIBackendRole.ASSISTANT)
-        self.update_memory(func_result_msg, OpenAIBackendRole.FUNCTION)
-
-        return func_record
-
-    def _structure_output_with_function(
-        self, response_format: Type[BaseModel]
-    ) -> Tuple[
-        List[BaseMessage],
-        List[str],
-        Dict[str, int],
-        str,
-        ToolCallingRecord,
-        int,
-    ]:
-        r"""Internal function of structuring the output of the agent based on
-        the given output schema.
-
-        Args:
-            response_format (Type[BaseModel]): The output schema to use for
-                structuring the output.
-
-        Returns:
-            Tuple[List[BaseMessage], List[str], Dict[str, int], str,
-                ToolCallingRecord, int]:
-                A tuple containing the output messages, finish reasons, usage
-                dictionary, response ID, function calling record, and number of
-                tokens.
-        """
-        from camel.toolkits import FunctionTool
-
-        schema_json = get_pydantic_object_schema(response_format)
-        func_str = json_to_function_code(schema_json)
-        func_callable = func_string_to_callable(func_str)
-        func = FunctionTool(func_callable)
-
-        original_model_dict = self.model_backend.model_config_dict
-
-        # Replace the original tools with the structuring function
-        self.tool_dict = {func.get_function_name(): 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()
-        (
-            response,
-            output_messages,
-            finish_reasons,
-            usage_dict,
-            response_id,
-        ) = self._step_model_response(openai_messages, num_tokens)
-
         if isinstance(response, ChatCompletion):
-            tool_call_record = self._step_tool_call_and_update(response)
+            return self._handle_batch_response(response)
         else:
-            raise ValueError(
-                "Structured output is not supported for stream responses."
-            )
+            return self._handle_stream_response(response, num_tokens)
 
-        for base_message_item in output_messages:
-            base_message_item.content = json.dumps(tool_call_record.result)
-
-        # Recover the original tools
-        self.model_backend.model_config_dict = original_model_dict
-
-        return (
-            output_messages,
-            finish_reasons,
-            usage_dict,
-            response_id,
-            tool_call_record,
-            num_tokens,
-        )
-
-    def _step_model_response(
+    async def _aget_model_response(
         self,
         openai_messages: List[OpenAIMessage],
         num_tokens: int,
-    ) -> tuple[
-        Union[ChatCompletion, Stream],
-        List[BaseMessage],
-        List[str],
-        Dict[str, int],
-        str,
-    ]:
+        response_format: Optional[Type[BaseModel]] = None,
+        tool_schemas: Optional[List[Dict[str, Any]]] = None,
+    ) -> ModelResponse:
         r"""Internal function for agent step model response."""
 
         response = None
-        # Obtain the model's response
-        for _ in range(len(self.model_backend.models)):
-            try:
-                response = self.model_backend.run(openai_messages)
-                break
-            except Exception as exc:
-                logger.error(
-                    f"An error occurred while running model "
-                    f"{self.model_backend.model_type}, "
-                    f"index: {self.model_backend.current_model_index}",
-                    exc_info=exc,
-                )
-                continue
-        if not response:
+        try:
+            response = await self.model_backend.arun(
+                openai_messages, response_format, tool_schemas or None
+            )
+        except Exception as exc:
+            logger.error(
+                f"An error occurred while running model "
+                f"{self.model_backend.model_type}, "
+                f"index: {self.model_backend.current_model_index}",
+                exc_info=exc,
+            )
+            error_info = str(exc)
+
+        if not response and self.model_backend.num_models > 1:
             raise ModelProcessingError(
                 "Unable to process messages: none of the provided models "
                 "run succesfully."
             )
+        elif not response:
+            raise ModelProcessingError(
+                f"Unable to process messages: the only provided model "
+                f"did not run succesfully. Error: {error_info}"
+            )
 
         logger.info(
             f"Model {self.model_backend.model_type}, "
@@ -1119,20 +759,9 @@ class ChatAgent(BaseAgent):
         )
 
         if isinstance(response, ChatCompletion):
-            output_messages, finish_reasons, usage_dict, response_id = (
-                self.handle_batch_response(response)
-            )
+            return self._handle_batch_response(response)
         else:
-            output_messages, finish_reasons, usage_dict, response_id = (
-                self.handle_stream_response(response, num_tokens)
-            )
-        return (
-            response,
-            output_messages,
-            finish_reasons,
-            usage_dict,
-            response_id,
-        )
+            return await self._ahandle_stream_response(response, num_tokens)
 
     def _step_get_info(
         self,
@@ -1142,7 +771,7 @@ class ChatAgent(BaseAgent):
         response_id: str,
         tool_calls: List[ToolCallingRecord],
         num_tokens: int,
-        external_tool_request: Optional[ChatCompletionMessageToolCall] = None,
+        external_tool_call_request: Optional[ToolCallRequest] = None,
     ) -> Dict[str, Any]:
         r"""Process the output of a chat step and gather information about the
         step.
@@ -1162,9 +791,8 @@ class ChatAgent(BaseAgent):
             tool_calls (List[ToolCallingRecord]): Records of function calls
                 made during this step.
             num_tokens (int): The number of tokens used in this step.
-            external_tool_request (Optional[ChatCompletionMessageToolCall]):
-                Any external tool request made during this step.
-                (default: :obj:`None`)
+            external_tool_call_request (Optional[ToolCallRequest]): The
+                request for external tool call.
 
         Returns:
             Dict[str, Any]: A dictionary containing information about the chat
@@ -1194,103 +822,114 @@ class ChatAgent(BaseAgent):
         if self.terminated and termination_reason is not None:
             finish_reasons = [termination_reason] * len(finish_reasons)
 
-        info = self.get_info(
+        return get_info_dict(
             response_id,
             usage_dict,
             finish_reasons,
             num_tokens,
             tool_calls,
-            external_tool_request,
+            external_tool_call_request,
         )
-        return info
 
-    def handle_batch_response(
+    def _handle_batch_response(
         self, response: ChatCompletion
-    ) -> Tuple[List[BaseMessage], List[str], Dict[str, int], str]:
+    ) -> ModelResponse:
         r"""Process a batch response from the model and extract the necessary
         information.
 
         Args:
-            response (dict): Model response.
+            response (ChatCompletion): Model response.
 
         Returns:
-            tuple: A tuple of list of output `ChatMessage`, list of
-                finish reasons, usage dictionary, and response id.
+            _ModelResponse: parsed model response.
         """
         output_messages: List[BaseMessage] = []
         for choice in response.choices:
+            meta_dict = {}
+            if logprobs_info := handle_logprobs(choice):
+                meta_dict["logprobs_info"] = logprobs_info
+
             chat_message = BaseMessage(
                 role_name=self.role_name,
                 role_type=self.role_type,
-                meta_dict=dict(),
+                meta_dict=meta_dict,
                 content=choice.message.content or "",
-                parsed=getattr(choice.message, 'parsed', None),
+                parsed=getattr(choice.message, "parsed", None),
             )
-            # Process log probabilities and append to the message meta information
-            if choice.logprobs is not None:
-                tokens_logprobs = choice.logprobs.content
-
-                if tokens_logprobs is not None:
-                    # Extract and structure logprob information
-                    logprobs_info = [
-                        {
-                            "token": token_logprob.token,
-                            "logprob": token_logprob.logprob,
-                            "top_logprobs": [
-                                (top_logprob.token, top_logprob.logprob)
-                                for top_logprob in token_logprob.top_logprobs
-                            ],
-                        }
-                        for token_logprob in tokens_logprobs
-                    ]
-                # Ensure meta_dict exists before adding logprobs info
-                if chat_message.meta_dict is None:
-                    chat_message.meta_dict = {}
-                chat_message.meta_dict["logprobs_info"] = logprobs_info
-            # Append the processed chat message to output
+
             output_messages.append(chat_message)
 
         finish_reasons = [
             str(choice.finish_reason) for choice in response.choices
         ]
-        usage = (
-            self._safe_model_dump(response.usage)
-            if response.usage is not None
-            else {}
-        )
-        return (
-            output_messages,
-            finish_reasons,
-            usage,
-            response.id,
-        )
 
-    def _safe_model_dump(self, obj) -> dict:
-        r"""Safely dump a Pydantic model to a dictionary.
+        usage = {}
+        if response.usage is not None:
+            usage = safe_model_dump(response.usage)
+
+        tool_call_request: Optional[ToolCallRequest] = None
+        if tool_calls := response.choices[0].message.tool_calls:
+            tool_name = tool_calls[0].function.name
+            tool_call_id = tool_calls[0].id
+            args = json.loads(tool_calls[0].function.arguments)
+            tool_call_request = ToolCallRequest(
+                tool_name=tool_name, args=args, tool_call_id=tool_call_id
+            )
 
-        This method attempts to use the `model_dump` method if available,
-        otherwise it falls back to the `dict` method.
+        return ModelResponse(
+            response=response,
+            tool_call_request=tool_call_request,
+            output_messages=output_messages,
+            finish_reasons=finish_reasons,
+            usage_dict=usage,
+            response_id=response.id or "",
+        )
+
+    def _handle_stream_response(
+        self,
+        response: Stream[ChatCompletionChunk],
+        prompt_tokens: int,
+    ) -> ModelResponse:
+        r"""Process a stream response from the model and extract the necessary
+        information.
 
         Args:
-            obj: The Pydantic model instance to be dumped.
+            response (dict): Model response.
+            prompt_tokens (int): Number of input prompt tokens.
 
         Returns:
-            dict: A dictionary representation of the Pydantic model.
+            _ModelResponse: a parsed model response.
         """
-        # Check if the `model_dump` method exists (Pydantic v2)
-        if hasattr(obj, 'model_dump'):
-            return obj.model_dump()
-        # Fallback to `dict()` method (Pydantic v1)
-        elif hasattr(obj, 'dict'):
-            return obj.dict()
-        else:
-            raise TypeError("The object is not a Pydantic model")
+        content_dict: defaultdict = defaultdict(lambda: "")
+        finish_reasons_dict: defaultdict = defaultdict(lambda: "")
+        output_messages: List[BaseMessage] = []
+        response_id: str = ""
+        # All choices in one response share one role
+        for chunk in response:
+            response_id = chunk.id
+            self._handle_chunk(
+                chunk, content_dict, finish_reasons_dict, output_messages
+            )
+        finish_reasons = [
+            finish_reasons_dict[i] for i in range(len(finish_reasons_dict))
+        ]
+        usage_dict = self.get_usage_dict(output_messages, prompt_tokens)
+
+        # TODO: Handle tool calls
+        return ModelResponse(
+            response=response,
+            tool_call_request=None,
+            output_messages=output_messages,
+            finish_reasons=finish_reasons,
+            usage_dict=usage_dict,
+            response_id=response_id,
+        )
 
-    def handle_stream_response(
+    async def _ahandle_stream_response(
         self,
-        response: Stream[ChatCompletionChunk],
+        response: AsyncStream[ChatCompletionChunk],
         prompt_tokens: int,
-    ) -> Tuple[List[BaseMessage], List[str], Dict[str, int], str]:
+    ) -> ModelResponse:
         r"""Process a stream response from the model and extract the necessary
         information.
 
@@ -1299,37 +938,58 @@ class ChatAgent(BaseAgent):
             prompt_tokens (int): Number of input prompt tokens.
 
         Returns:
-            tuple: A tuple of list of output `ChatMessage`, list of
-                finish reasons, usage dictionary, and response id.
+            _ModelResponse: a parsed model response.
         """
         content_dict: defaultdict = defaultdict(lambda: "")
         finish_reasons_dict: defaultdict = defaultdict(lambda: "")
         output_messages: List[BaseMessage] = []
         response_id: str = ""
         # All choices in one response share one role
-        for chunk in response:
+        async for chunk in response:
             response_id = chunk.id
-            for choice in chunk.choices:
-                index = choice.index
-                delta = choice.delta
-                if delta.content is not None:
-                    # When response has not been stopped
-                    # Notice that only the first chunk_dict has the "role"
-                    content_dict[index] += delta.content
-                if choice.finish_reason:
-                    finish_reasons_dict[index] = choice.finish_reason
-                    chat_message = BaseMessage(
-                        role_name=self.role_name,
-                        role_type=self.role_type,
-                        meta_dict=dict(),
-                        content=content_dict[index],
-                    )
-                    output_messages.append(chat_message)
+            self._handle_chunk(
+                chunk, content_dict, finish_reasons_dict, output_messages
+            )
         finish_reasons = [
             finish_reasons_dict[i] for i in range(len(finish_reasons_dict))
         ]
         usage_dict = self.get_usage_dict(output_messages, prompt_tokens)
-        return output_messages, finish_reasons, usage_dict, response_id
+
+        # TODO: Handle tool calls
+        return ModelResponse(
+            response=response,
+            tool_call_request=None,
+            output_messages=output_messages,
+            finish_reasons=finish_reasons,
+            usage_dict=usage_dict,
+            response_id=response_id,
+        )
+
+    def _handle_chunk(
+        self,
+        chunk: ChatCompletionChunk,
+        content_dict: defaultdict,
+        finish_reasons_dict: defaultdict,
+        output_messages: List[BaseMessage],
+    ) -> None:
+        r"""Handle a chunk of the model response."""
+        for choice in chunk.choices:
+            index = choice.index
+            delta = choice.delta
+            if delta.content is not None:
+                content_dict[index] += delta.content
+
+            if not choice.finish_reason:
+                continue
+
+            finish_reasons_dict[index] = choice.finish_reason
+            chat_message = BaseMessage(
+                role_name=self.role_name,
+                role_type=self.role_type,
+                meta_dict=dict(),
+                content=content_dict[index],
+            )
+            output_messages.append(chat_message)
 
     def _step_token_exceed(
         self,
@@ -1351,9 +1011,8 @@ class ChatAgent(BaseAgent):
                 information about token number and called functions.
         """
         self.terminated = True
-        output_messages: List[BaseMessage] = []
 
-        info = self.get_info(
+        info = get_info_dict(
             None,
             None,
             [termination_reason],
@@ -1362,111 +1021,53 @@ class ChatAgent(BaseAgent):
         )
 
         return ChatAgentResponse(
-            msgs=output_messages,
+            msgs=[],
             terminated=self.terminated,
             info=info,
         )
 
-    def _step_tool_call(
+    def _execute_tool(
         self,
-        response: ChatCompletion,
-    ) -> Tuple[
-        FunctionCallingMessage, FunctionCallingMessage, ToolCallingRecord
-    ]:
-        r"""Execute the function with arguments following the model's response.
+        tool_call_request: ToolCallRequest,
+    ) -> ToolCallingRecord:
+        r"""Execute the tool with arguments following the model's response.
 
         Args:
-            response (Dict[str, Any]): The response obtained by calling the
-                model.
+            tool_call_request (_ToolCallRequest): The tool call request.
 
         Returns:
-            tuple: A tuple consisting of two obj:`FunctionCallingMessage`,
-                one about the arguments and the other about the execution
-                result, and a struct for logging information about this
+            FunctionCallingRecord: A struct for logging information about this
                 function call.
         """
-        choice = response.choices[0]
-        if choice.message.tool_calls is None:
-            raise RuntimeError("Tool call is None")
-        func_name = choice.message.tool_calls[0].function.name
-
-        arguments_str = choice.message.tool_calls[0].function.arguments
-        args = self._safe_json_loads(arguments_str)
-
-        tool = self.tool_dict[func_name]
+        func_name = tool_call_request.tool_name
+        args = tool_call_request.args
+        tool_call_id = tool_call_request.tool_call_id
+        tool = self._internal_tools[func_name]
         result = tool(**args)
-        tool_call_id = choice.message.tool_calls[0].id
 
-        assist_msg = FunctionCallingMessage(
-            role_name=self.role_name,
-            role_type=self.role_type,
-            meta_dict=None,
-            content="",
-            func_name=func_name,
-            args=args,
-            tool_call_id=tool_call_id,
-        )
-        func_msg = FunctionCallingMessage(
-            role_name=self.role_name,
-            role_type=self.role_type,
-            meta_dict=None,
-            content="",
-            func_name=func_name,
-            result=result,
-            tool_call_id=tool_call_id,
-        )
-
-        # Record information about this function call
-        func_record = ToolCallingRecord(
-            tool_name=func_name,
-            args=args,
-            result=result,
-            tool_call_id=tool_call_id,
-        )
-        return assist_msg, func_msg, func_record
-
-    def _safe_json_loads(self, arguments_str):
-        # Replace Python types with their JSON equivalents
-        arguments_str = arguments_str.replace("None", "null")
-        arguments_str = arguments_str.replace("True", "true")
-        arguments_str = arguments_str.replace("False", "false")
-
-        # Attempt to parse the corrected string
-        try:
-            return json.loads(arguments_str)
-        except json.JSONDecodeError as e:
-            raise ValueError(f"Invalid JSON format: {e}")
+        return self._record_tool_calling(func_name, args, result, tool_call_id)
 
-    async def step_tool_call_async(
+    async def _aexecute_tool(
         self,
-        response: ChatCompletion,
-    ) -> Tuple[
-        FunctionCallingMessage, FunctionCallingMessage, ToolCallingRecord
-    ]:
-        r"""Execute the async function with arguments following the model's
-        response.
-
-        Args:
-            response (Dict[str, Any]): The response obtained by calling the
-                model.
-
-        Returns:
-            tuple: A tuple consisting of two obj:`FunctionCallingMessage`,
-                one about the arguments and the other about the execution
-                result, and a struct for logging information about this
-                function call.
+        tool_call_request: ToolCallRequest,
+    ) -> ToolCallingRecord:
+        func_name = tool_call_request.tool_name
+        args = tool_call_request.args
+        tool_call_id = tool_call_request.tool_call_id
+        tool = self._internal_tools[func_name]
+        result = await tool.async_call(**args)
+        return self._record_tool_calling(func_name, args, result, tool_call_id)
+
+    def _record_tool_calling(
+        self,
+        func_name: str,
+        args: Dict[str, Any],
+        result: Any,
+        tool_call_id: str,
+    ):
+        r"""Record the tool calling information in the memory, and return the
+        tool calling record.
         """
-        # Note that when function calling is enabled, `n` is set to 1.
-        choice = response.choices[0]
-        if choice.message.tool_calls is None:
-            raise RuntimeError("Tool call is None")
-        func_name = choice.message.tool_calls[0].function.name
-
-        args = json.loads(choice.message.tool_calls[0].function.arguments)
-        tool = self.tool_dict[func_name]
-        result = await tool(**args)
-        tool_call_id = choice.message.tool_calls[0].id
-
         assist_msg = FunctionCallingMessage(
             role_name=self.role_name,
             role_type=self.role_type,
@@ -1486,14 +1087,18 @@ class ChatAgent(BaseAgent):
             tool_call_id=tool_call_id,
         )
 
-        # Record information about this function call
-        func_record = ToolCallingRecord(
+        self.update_memory(assist_msg, OpenAIBackendRole.ASSISTANT)
+        self.update_memory(func_msg, OpenAIBackendRole.FUNCTION)
+
+        # Record information about this tool call
+        tool_record = ToolCallingRecord(
             tool_name=func_name,
             args=args,
             result=result,
             tool_call_id=tool_call_id,
         )
-        return assist_msg, func_msg, func_record
+
+        return tool_record
 
     def get_usage_dict(
         self, output_messages: List[BaseMessage], prompt_tokens: int
@@ -1508,15 +1113,15 @@ class ChatAgent(BaseAgent):
             dict: Usage dictionary.
         """
         encoding = get_model_encoding(self.model_type.value_for_tiktoken)
-        completion_tokens = 0
-        for message in output_messages:
-            completion_tokens += len(encoding.encode(message.content))
-        usage_dict = dict(
+        completion_tokens = sum(
+            len(encoding.encode(message.content))
+            for message in output_messages
+        )
+        return dict(
             completion_tokens=completion_tokens,
             prompt_tokens=prompt_tokens,
             total_tokens=completion_tokens + prompt_tokens,
         )
-        return usage_dict
 
     def add_model_scheduling_strategy(self, name: str, strategy_fn: Callable):
         r"""Add a scheduling strategy method provided by user to ModelManger.