camel-ai 0.2.57__py3-none-any.whl → 0.2.59__py3-none-any.whl

camel/__init__.py

@@ -14,11 +14,10 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.57'
+__version__ = '0.2.59'
 
 __all__ = [
     '__version__',
-    'camel',
     'disable_logging',
     'enable_logging',
     'set_log_level',

camel/agents/chat_agent.py

@@ -442,6 +442,11 @@ class ChatAgent(BaseAgent):
         new_tool = convert_to_function_tool(tool)
         self._internal_tools[new_tool.get_function_name()] = new_tool
 
+    def add_tools(self, tools: List[Union[FunctionTool, Callable]]) -> None:
+        r"""Add a list of tools to the agent."""
+        for tool in tools:
+            self.add_tool(tool)
+
     def add_external_tool(
         self, tool: Union[FunctionTool, Callable, Dict[str, Any]]
     ) -> None:
@@ -462,6 +467,11 @@ class ChatAgent(BaseAgent):
             return True
         return False
 
+    def remove_tools(self, tool_names: List[str]) -> None:
+        r"""Remove a list of tools from the agent by name."""
+        for tool_name in tool_names:
+            self.remove_tool(tool_name)
+
     def remove_external_tool(self, tool_name: str) -> bool:
         r"""Remove an external tool from the agent by name.
 
@@ -748,9 +758,17 @@ class ChatAgent(BaseAgent):
         tool_call_records: List[ToolCallingRecord] = []
         external_tool_call_requests: Optional[List[ToolCallRequest]] = None
 
+        accumulated_context_tokens = (
+            0  # This tracks cumulative context tokens, not API usage tokens
+        )
+
+        # Initialize token usage tracker
+        step_token_usage = self._create_token_usage_tracker()
+
         while True:
             try:
                 openai_messages, num_tokens = self.memory.get_context()
+                accumulated_context_tokens += num_tokens
             except RuntimeError as e:
                 return self._step_terminate(
                     e.args[1], tool_call_records, "max_tokens_exceeded"
@@ -758,16 +776,23 @@ class ChatAgent(BaseAgent):
             # Get response from model backend
             response = self._get_model_response(
                 openai_messages,
-                num_tokens,
+                accumulated_context_tokens,  # Cumulative context tokens
                 response_format,
                 self._get_full_tool_schemas(),
             )
 
+            # Accumulate API token usage
+            self._update_token_usage_tracker(
+                step_token_usage, response.usage_dict
+            )
+
             # Terminate Agent if stop_event is set
             if self.stop_event and self.stop_event.is_set():
                 # Use the _step_terminate to terminate the agent with reason
                 return self._step_terminate(
-                    num_tokens, tool_call_records, "termination_triggered"
+                    accumulated_context_tokens,
+                    tool_call_records,
+                    "termination_triggered",
                 )
 
             if tool_call_requests := response.tool_call_requests:
@@ -803,8 +828,11 @@ class ChatAgent(BaseAgent):
         return self._convert_to_chatagent_response(
             response,
             tool_call_records,
-            num_tokens,
+            accumulated_context_tokens,
             external_tool_call_requests,
+            step_token_usage["prompt_tokens"],
+            step_token_usage["completion_tokens"],
+            step_token_usage["total_tokens"],
         )
 
     @property
@@ -847,9 +875,16 @@ class ChatAgent(BaseAgent):
 
         tool_call_records: List[ToolCallingRecord] = []
         external_tool_call_requests: Optional[List[ToolCallRequest]] = None
+        accumulated_context_tokens = (
+            0  # This tracks cumulative context tokens, not API usage tokens
+        )
+
+        # Initialize token usage tracker
+        step_token_usage = self._create_token_usage_tracker()
         while True:
             try:
                 openai_messages, num_tokens = self.memory.get_context()
+                accumulated_context_tokens += num_tokens
             except RuntimeError as e:
                 return self._step_terminate(
                     e.args[1], tool_call_records, "max_tokens_exceeded"
@@ -857,7 +892,7 @@ class ChatAgent(BaseAgent):
 
             response = await self._aget_model_response(
                 openai_messages,
-                num_tokens,
+                accumulated_context_tokens,
                 response_format,
                 self._get_full_tool_schemas(),
             )
@@ -866,7 +901,9 @@ class ChatAgent(BaseAgent):
             if self.stop_event and self.stop_event.is_set():
                 # Use the _step_terminate to terminate the agent with reason
                 return self._step_terminate(
-                    num_tokens, tool_call_records, "termination_triggered"
+                    accumulated_context_tokens,
+                    tool_call_records,
+                    "termination_triggered",
                 )
 
             if tool_call_requests := response.tool_call_requests:
@@ -900,28 +937,68 @@ class ChatAgent(BaseAgent):
         await self._aformat_response_if_needed(response, response_format)
         self._record_final_output(response.output_messages)
 
+        # Create token usage tracker for this step
+        step_token_usage = self._create_token_usage_tracker()
+
+        # Update with response usage
+        self._update_token_usage_tracker(step_token_usage, response.usage_dict)
+
         return self._convert_to_chatagent_response(
             response,
             tool_call_records,
-            num_tokens,
+            accumulated_context_tokens,
             external_tool_call_requests,
+            step_token_usage["prompt_tokens"],
+            step_token_usage["completion_tokens"],
+            step_token_usage["total_tokens"],
         )
 
+    def _create_token_usage_tracker(self) -> Dict[str, int]:
+        r"""Creates a fresh token usage tracker for a step.
+
+        Returns:
+            Dict[str, int]: A dictionary for tracking token usage.
+        """
+        return {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
+
+    def _update_token_usage_tracker(
+        self, tracker: Dict[str, int], usage_dict: Dict[str, int]
+    ) -> None:
+        r"""Updates a token usage tracker with values from a usage dictionary.
+
+        Args:
+            tracker (Dict[str, int]): The token usage tracker to update.
+            usage_dict (Dict[str, int]): The usage dictionary with new values.
+        """
+        tracker["prompt_tokens"] += usage_dict.get("prompt_tokens", 0)
+        tracker["completion_tokens"] += usage_dict.get("completion_tokens", 0)
+        tracker["total_tokens"] += usage_dict.get("total_tokens", 0)
+
     def _convert_to_chatagent_response(
         self,
         response: ModelResponse,
         tool_call_records: List[ToolCallingRecord],
-        num_tokens: int,
+        num_tokens: int,  # Context tokens from the last call in step
         external_tool_call_requests: Optional[List[ToolCallRequest]],
+        step_api_prompt_tokens: int = 0,
+        step_api_completion_tokens: int = 0,
+        step_api_total_tokens: int = 0,
     ) -> ChatAgentResponse:
         r"""Parse the final model response into the chat agent response."""
+        # Create usage_dict for the current step's API calls
+        step_api_usage_dict = {
+            "prompt_tokens": step_api_prompt_tokens,
+            "completion_tokens": step_api_completion_tokens,
+            "total_tokens": step_api_total_tokens,
+        }
+
         info = self._step_get_info(
             response.output_messages,
             response.finish_reasons,
-            response.usage_dict,
+            step_api_usage_dict,  # Pass step-specific API usage here
             response.response_id,
             tool_call_records,
-            num_tokens,
+            num_tokens,  # This is context tokens, not API usage
             external_tool_call_requests,
         )
 
@@ -1570,6 +1647,56 @@ class ChatAgent(BaseAgent):
         """
         self.model_backend.add_strategy(name, strategy_fn)
 
+    def clone(self, with_memory: bool = False) -> ChatAgent:
+        r"""Creates a new instance of :obj:`ChatAgent` with the same
+        configuration as the current instance.
+
+        Args:
+            with_memory (bool): Whether to copy the memory (conversation
+                history) to the new agent. If True, the new agent will have
+                the same conversation history. If False, the new agent will
+                have a fresh memory with only the system message.
+                (default: :obj:`False`)
+
+        Returns:
+            ChatAgent: A new instance of :obj:`ChatAgent` with the same
+                configuration.
+        """
+        # Create a new instance with the same configuration
+        # If with_memory is True, set system_message to None
+        # If with_memory is False, use the original system message
+        # To avoid duplicated system memory.
+        system_message = None if with_memory else self._original_system_message
+
+        new_agent = ChatAgent(
+            system_message=system_message,
+            model=self.model_backend.models,  # Pass the existing model_backend
+            memory=None,  # clone memory later
+            message_window_size=getattr(self.memory, "window_size", None),
+            token_limit=getattr(
+                self.memory.get_context_creator(), "token_limit", None
+            ),
+            output_language=self._output_language,
+            tools=list(self._internal_tools.values()),
+            external_tools=[
+                schema for schema in self._external_tool_schemas.values()
+            ],
+            response_terminators=self.response_terminators,
+            scheduling_strategy=self.model_backend.scheduling_strategy.__name__,
+            single_iteration=self.single_iteration,
+            stop_event=self.stop_event,
+        )
+
+        # Copy memory if requested
+        if with_memory:
+            # Get all records from the current memory
+            context_records = self.memory.retrieve()
+            # Write them to the new agent's memory
+            for context_record in context_records:
+                new_agent.memory.write_record(context_record.memory_record)
+
+        return new_agent
+
     def __repr__(self) -> str:
         r"""Returns a string representation of the :obj:`ChatAgent`.
 

camel/agents/critic_agent.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import random
 import warnings
-from typing import Any, Dict, Optional, Sequence
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 
 from colorama import Fore
 
@@ -22,6 +22,7 @@ from camel.memories import AgentMemory
 from camel.messages import BaseMessage
 from camel.models import BaseModelBackend
 from camel.responses import ChatAgentResponse
+from camel.types import ModelPlatformType, ModelType
 from camel.utils import get_first_int, print_text_animated
 
 # AgentOps decorator setting
@@ -41,11 +42,18 @@ class CriticAgent(ChatAgent):
     r"""A class for the critic agent that assists in selecting an option.
 
     Args:
-        system_message (BaseMessage): The system message for the critic
-            agent.
-        model (BaseModelBackend, optional): The model backend to use for
-            generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_4O_MINI`)
+        system_message (Union[BaseMessage, str], optional): The system message
+            for the chat agent. (default: :obj:`None`)
+        model (Union[BaseModelBackend, Tuple[str, str], str, ModelType,
+            Tuple[ModelPlatformType, ModelType], List[BaseModelBackend],
+            List[str], List[ModelType], List[Tuple[str, str]],
+            List[Tuple[ModelPlatformType, ModelType]]], optional):
+            The model backend(s) to use. Can be a single instance,
+            a specification (string, enum, tuple), or a list of instances
+            or specifications to be managed by `ModelManager`. If a list of
+            specifications (not `BaseModelBackend` instances) is provided,
+            they will be instantiated using `ModelFactory`. (default:
+            :obj:`ModelPlatformType.DEFAULT` with `ModelType.DEFAULT`)
         message_window_size (int, optional): The maximum number of previous
             messages to include in the context window. If `None`, no windowing
             is performed. (default: :obj:`6`)
@@ -58,8 +66,21 @@ class CriticAgent(ChatAgent):
 
     def __init__(
         self,
-        system_message: BaseMessage,
-        model: Optional[BaseModelBackend] = None,
+        system_message: Optional[Union[BaseMessage, str]] = None,
+        model: Optional[
+            Union[
+                BaseModelBackend,
+                Tuple[str, str],
+                str,
+                ModelType,
+                Tuple[ModelPlatformType, ModelType],
+                List[BaseModelBackend],
+                List[str],
+                List[ModelType],
+                List[Tuple[str, str]],
+                List[Tuple[ModelPlatformType, ModelType]],
+            ]
+        ] = None,
         memory: Optional[AgentMemory] = None,
         message_window_size: int = 6,
         retry_attempts: int = 2,
@@ -200,3 +221,47 @@ class CriticAgent(ChatAgent):
             terminated=False,
             info={},
         )
+
+    def clone(self, with_memory: bool = False) -> 'CriticAgent':
+        r"""Creates a new instance of :obj:`CriticAgent` with the same
+        configuration as the current instance.
+
+        Args:
+            with_memory (bool): Whether to copy the memory (conversation
+                history) to the new agent. If True, the new agent will have
+                the same conversation history. If False, the new agent will
+                have a fresh memory with only the system message.
+                (default: :obj:`False`)
+
+        Returns:
+            CriticAgent: A new instance of :obj:`CriticAgent` with the same
+                configuration.
+        """
+        # Create a new instance with the same configuration
+        # If with_memory is True, set system_message to None
+        # If with_memory is False, use the original system message
+        # To avoid duplicated system memory.
+        system_message = None if with_memory else self._original_system_message
+
+        new_agent = CriticAgent(
+            system_message=system_message,
+            model=self.model_backend.models,  # Pass the existing model_backend
+            memory=None,  # clone memory later
+            message_window_size=getattr(self.memory, "window_size", 6),
+            retry_attempts=self.retry_attempts,
+            verbose=self.verbose,
+            logger_color=self.logger_color,
+        )
+
+        # Copy memory if requested
+        if with_memory:
+            # Get all records from the current memory
+            context_records = self.memory.retrieve()
+            # Write them to the new agent's memory
+            for context_record in context_records:
+                new_agent.memory.write_record(context_record.memory_record)
+
+        # Copy CriticAgent-specific attributes
+        new_agent.options_dict = self.options_dict.copy()
+
+        return new_agent