camel-ai 0.2.34__tar.gz → 0.2.35__tar.gz

{camel_ai-0.2.34 → camel_ai-0.2.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.34
+Version: 0.2.35
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel

{camel_ai-0.2.34 → camel_ai-0.2.35}/camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.34'
+__version__ = '0.2.35'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.34 → camel_ai-0.2.35}/camel/agents/_types.py

@@ -34,7 +34,7 @@ class ModelResponse(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     response: Union[ChatCompletion, Stream, AsyncStream]
-    tool_call_request: Optional[ToolCallRequest]
+    tool_call_requests: Optional[List[ToolCallRequest]]
     output_messages: List[BaseMessage]
     finish_reasons: List[str]
     usage_dict: Dict[str, Any]

{camel_ai-0.2.34 → camel_ai-0.2.35}/camel/agents/_utils.py

@@ -136,7 +136,7 @@ def get_info_dict(
     termination_reasons: List[str],
     num_tokens: int,
     tool_calls: List[ToolCallingRecord],
-    external_tool_call_request: Optional[ToolCallRequest] = None,
+    external_tool_call_requests: Optional[List[ToolCallRequest]] = None,
 ) -> Dict[str, Any]:
     r"""Returns a dictionary containing information about the chat session.
 
@@ -149,8 +149,8 @@ def get_info_dict(
         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_call_request (Optional[ToolCallRequest]): The
-            request for external tool call.
+        external_tool_call_requests (Optional[List[ToolCallRequest]]): The
+            requests for external tool calls.
 
 
     Returns:
@@ -162,7 +162,7 @@ def get_info_dict(
         "termination_reasons": termination_reasons,
         "num_tokens": num_tokens,
         "tool_calls": tool_calls,
-        "external_tool_call_request": external_tool_call_request,
+        "external_tool_call_requests": external_tool_call_requests,
     }
 
 

{camel_ai-0.2.34 → camel_ai-0.2.35}/camel/agents/chat_agent.py

@@ -16,7 +16,10 @@ from __future__ import annotations
 import json
 import logging
 import textwrap
+import uuid
 from collections import defaultdict
+from datetime import datetime
+from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -59,6 +62,7 @@ from camel.models import (
 )
 from camel.prompts import TextPrompt
 from camel.responses import ChatAgentResponse
+from camel.storages import JsonStorage
 from camel.toolkits import FunctionTool
 from camel.types import (
     ChatCompletion,
@@ -138,6 +142,8 @@ class ChatAgent(BaseAgent):
             the next model in ModelManager. (default: :str:`round_robin`)
         single_iteration (bool): Whether to let the agent perform only one
             model calling at each step. (default: :obj:`False`)
+        agent_id (str, optional): The ID of the agent. If not provided, a
+            random UUID will be generated. (default: :obj:`None`)
     """
 
     def __init__(
@@ -157,6 +163,7 @@ class ChatAgent(BaseAgent):
         response_terminators: Optional[List[ResponseTerminator]] = None,
         scheduling_strategy: str = "round_robin",
         single_iteration: bool = False,
+        agent_id: Optional[str] = None,
     ) -> None:
         # Set up model backend
         self.model_backend = ModelManager(
@@ -171,16 +178,25 @@ class ChatAgent(BaseAgent):
             scheduling_strategy=scheduling_strategy,
         )
         self.model_type = self.model_backend.model_type
+        # Assign unique ID
+        self.agent_id = agent_id if agent_id else str(uuid.uuid4())
 
         # Set up memory
         context_creator = ScoreBasedContextCreator(
             self.model_backend.token_counter,
             token_limit or self.model_backend.token_limit,
         )
+
         self.memory: AgentMemory = memory or ChatHistoryMemory(
-            context_creator, window_size=message_window_size
+            context_creator,
+            window_size=message_window_size,
+            agent_id=self.agent_id,
         )
 
+        # So we don't have to pass agent_id when we define memory
+        if memory is not None:
+            memory.agent_id = self.agent_id
+
         # Set up system message and initialize messages
         self._original_system_message = (
             BaseMessage.make_assistant_message(
@@ -321,9 +337,101 @@ class ChatAgent(BaseAgent):
             role (OpenAIBackendRole): The backend role type.
         """
         self.memory.write_record(
-            MemoryRecord(message=message, role_at_backend=role)
+            MemoryRecord(
+                message=message,
+                role_at_backend=role,
+                timestamp=datetime.now().timestamp(),
+                agent_id=self.agent_id,
+            )
         )
 
+    def load_memory(self, memory: AgentMemory) -> None:
+        r"""Load the provided memory into the agent.
+
+        Args:
+            memory (AgentMemory): The memory to load into the agent.
+
+        Returns:
+            None
+        """
+
+        for context_record in memory.retrieve():
+            self.memory.write_record(context_record.memory_record)
+        logger.info(f"Memory loaded from {memory}")
+
+    def load_memory_from_path(self, path: str) -> None:
+        r"""Loads memory records from a JSON file filtered by this agent's ID.
+
+        Args:
+            path (str): The file path to a JSON memory file that uses
+                JsonStorage.
+
+        Raises:
+            ValueError: If no matching records for the agent_id are found
+                (optional check; commented out below).
+        """
+        json_store = JsonStorage(Path(path))
+        all_records = json_store.load()
+
+        if not all_records:
+            raise ValueError(
+                f"No records found for agent_id={self.agent_id} in {path}"
+            )
+
+        for record_dict in all_records:
+            # Validate the record dictionary before conversion
+            required_keys = ['message', 'role_at_backend', 'agent_id']
+            if not all(key in record_dict for key in required_keys):
+                logger.warning(
+                    f"Skipping invalid record: missing required "
+                    f"keys in {record_dict}"
+                )
+                continue
+
+            # Validate message structure in the record
+            if (
+                not isinstance(record_dict['message'], dict)
+                or '__class__' not in record_dict['message']
+            ):
+                logger.warning(
+                    f"Skipping invalid record: malformed message "
+                    f"structure in {record_dict}"
+                )
+                continue
+
+            try:
+                record = MemoryRecord.from_dict(record_dict)
+                self.memory.write_records([record])
+            except Exception as e:
+                logger.warning(
+                    f"Error converting record to MemoryRecord: {e}. "
+                    f"Record: {record_dict}"
+                )
+        logger.info(f"Memory loaded from {path}")
+
+    def save_memory(self, path: str) -> None:
+        r"""Retrieves the current conversation data from memory and writes it
+        into a JSON file using JsonStorage.
+
+        Args:
+            path (str): Target file path to store JSON data.
+        """
+        json_store = JsonStorage(Path(path))
+        context_records = self.memory.retrieve()
+        to_save = [cr.memory_record.to_dict() for cr in context_records]
+        json_store.save(to_save)
+        logger.info(f"Memory saved to {path}")
+
+    def clear_memory(self) -> None:
+        r"""Clear the agent's memory and reset to initial state.
+
+        Returns:
+            None
+        """
+        self.memory.clear()
+        if self.system_message is not None:
+            self.update_memory(self.system_message, OpenAIBackendRole.SYSTEM)
+
     def _generate_system_message_for_output_language(
         self,
     ) -> Optional[BaseMessage]:
@@ -474,7 +582,7 @@ class ChatAgent(BaseAgent):
         self.update_memory(input_message, OpenAIBackendRole.USER)
 
         tool_call_records: List[ToolCallingRecord] = []
-        external_tool_call_request: Optional[ToolCallRequest] = None
+        external_tool_call_requests: Optional[List[ToolCallRequest]] = None
 
         while True:
             try:
@@ -494,12 +602,26 @@ class ChatAgent(BaseAgent):
             if self.single_iteration:
                 break
 
-            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
+            if tool_call_requests := response.tool_call_requests:
+                # Process all tool calls
+                for tool_call_request in tool_call_requests:
+                    if (
+                        tool_call_request.tool_name
+                        in self._external_tool_schemas
+                    ):
+                        if external_tool_call_requests is None:
+                            external_tool_call_requests = []
+                        external_tool_call_requests.append(tool_call_request)
+                    else:
+                        tool_call_records.append(
+                            self._execute_tool(tool_call_request)
+                        )
+
+                # If we found external tool calls, break the loop
+                if external_tool_call_requests:
                     break
 
-                tool_call_records.append(self._execute_tool(tool_call_request))
+                # If we're still here, continue the loop
                 continue
 
             break
@@ -508,7 +630,10 @@ class ChatAgent(BaseAgent):
         self._record_final_output(response.output_messages)
 
         return self._convert_to_chatagent_response(
-            response, tool_call_records, num_tokens, external_tool_call_request
+            response,
+            tool_call_records,
+            num_tokens,
+            external_tool_call_requests,
         )
 
     @property
@@ -550,7 +675,7 @@ class ChatAgent(BaseAgent):
         self.update_memory(input_message, OpenAIBackendRole.USER)
 
         tool_call_records: List[ToolCallingRecord] = []
-        external_tool_call_request: Optional[ToolCallRequest] = None
+        external_tool_call_requests: Optional[List[ToolCallRequest]] = None
         while True:
             try:
                 openai_messages, num_tokens = self.memory.get_context()
@@ -569,13 +694,27 @@ class ChatAgent(BaseAgent):
             if self.single_iteration:
                 break
 
-            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
+            if tool_call_requests := response.tool_call_requests:
+                # Process all tool calls
+                for tool_call_request in tool_call_requests:
+                    if (
+                        tool_call_request.tool_name
+                        in self._external_tool_schemas
+                    ):
+                        if external_tool_call_requests is None:
+                            external_tool_call_requests = []
+                        external_tool_call_requests.append(tool_call_request)
+
+                    tool_call_record = await self._aexecute_tool(
+                        tool_call_request
+                    )
+                    tool_call_records.append(tool_call_record)
+
+                # If we found an external tool call, break the loop
+                if external_tool_call_requests:
                     break
 
-                tool_call_record = await self._aexecute_tool(tool_call_request)
-                tool_call_records.append(tool_call_record)
+                # If we're still here, continue the loop
                 continue
 
             break
@@ -584,7 +723,10 @@ class ChatAgent(BaseAgent):
         self._record_final_output(response.output_messages)
 
         return self._convert_to_chatagent_response(
-            response, tool_call_records, num_tokens, external_tool_call_request
+            response,
+            tool_call_records,
+            num_tokens,
+            external_tool_call_requests,
         )
 
     def _convert_to_chatagent_response(
@@ -592,7 +734,7 @@ class ChatAgent(BaseAgent):
         response: ModelResponse,
         tool_call_records: List[ToolCallingRecord],
         num_tokens: int,
-        external_tool_call_request: Optional[ToolCallRequest],
+        external_tool_call_requests: Optional[List[ToolCallRequest]],
     ) -> ChatAgentResponse:
         r"""Parse the final model response into the chat agent response."""
         info = self._step_get_info(
@@ -602,7 +744,7 @@ class ChatAgent(BaseAgent):
             response.response_id,
             tool_call_records,
             num_tokens,
-            external_tool_call_request,
+            external_tool_call_requests,
         )
 
         return ChatAgentResponse(
@@ -853,7 +995,7 @@ class ChatAgent(BaseAgent):
         response_id: str,
         tool_calls: List[ToolCallingRecord],
         num_tokens: int,
-        external_tool_call_request: Optional[ToolCallRequest] = None,
+        external_tool_call_requests: Optional[List[ToolCallRequest]] = None,
     ) -> Dict[str, Any]:
         r"""Process the output of a chat step and gather information about the
         step.
@@ -910,7 +1052,7 @@ class ChatAgent(BaseAgent):
             finish_reasons,
             num_tokens,
             tool_calls,
-            external_tool_call_request,
+            external_tool_call_requests,
         )
 
     def _handle_batch_response(
@@ -949,18 +1091,21 @@ class ChatAgent(BaseAgent):
         if response.usage is not None:
             usage = safe_model_dump(response.usage)
 
-        tool_call_request: Optional[ToolCallRequest] = None
+        tool_call_requests: Optional[List[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
-            )
+            tool_call_requests = []
+            for tool_call in tool_calls:
+                tool_name = tool_call.function.name
+                tool_call_id = tool_call.id
+                args = json.loads(tool_call.function.arguments)
+                tool_call_request = ToolCallRequest(
+                    tool_name=tool_name, args=args, tool_call_id=tool_call_id
+                )
+                tool_call_requests.append(tool_call_request)
 
         return ModelResponse(
             response=response,
-            tool_call_request=tool_call_request,
+            tool_call_requests=tool_call_requests,
             output_messages=output_messages,
             finish_reasons=finish_reasons,
             usage_dict=usage,
@@ -1000,7 +1145,7 @@ class ChatAgent(BaseAgent):
         # TODO: Handle tool calls
         return ModelResponse(
             response=response,
-            tool_call_request=None,
+            tool_call_requests=None,
             output_messages=output_messages,
             finish_reasons=finish_reasons,
             usage_dict=usage_dict,
@@ -1040,7 +1185,7 @@ class ChatAgent(BaseAgent):
         # TODO: Handle tool calls
         return ModelResponse(
             response=response,
-            tool_call_request=None,
+            tool_call_requests=None,
             output_messages=output_messages,
             finish_reasons=finish_reasons,
             usage_dict=usage_dict,

{camel_ai-0.2.34 → camel_ai-0.2.35}/camel/configs/openai_config.py

@@ -15,7 +15,7 @@ from __future__ import annotations
 
 from typing import Dict, Optional, Sequence, Type, Union
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 from camel.configs.base_config import BaseConfig
 
@@ -28,14 +28,14 @@ class ChatGPTConfig(BaseConfig):
         temperature (float, optional): Sampling temperature to use, between
             :obj:`0` and :obj:`2`. Higher values make the output more random,
             while lower values make it more focused and deterministic.
-            (default: :obj:`0.2`)
+            (default: :obj:`None`)
         top_p (float, optional): An alternative to sampling with temperature,
             called nucleus sampling, where the model considers the results of
             the tokens with top_p probability mass. So :obj:`0.1` means only
             the tokens comprising the top 10% probability mass are considered.
-            (default: :obj:`1.0`)
+            (default: :obj:`None`)
         n (int, optional): How many chat completion choices to generate for
-            each input message. (default: :obj:`1`)
+            each input message. (default: :obj:`None`)
         response_format (object, optional): An object specifying the format
             that the model must output. Compatible with GPT-4 Turbo and all
             GPT-3.5 Turbo models newer than gpt-3.5-turbo-1106. Setting to
@@ -51,7 +51,7 @@ class ChatGPTConfig(BaseConfig):
             max context length.
         stream (bool, optional): If True, partial message deltas will be sent
             as data-only server-sent events as they become available.
-            (default: :obj:`False`)
+            (default: :obj:`None`)
         stop (str or list, optional): Up to :obj:`4` sequences where the API
             will stop generating further tokens. (default: :obj:`None`)
         max_tokens (int, optional): The maximum number of tokens to generate
@@ -62,12 +62,12 @@ class ChatGPTConfig(BaseConfig):
             :obj:`2.0`. Positive values penalize new tokens based on whether
             they appear in the text so far, increasing the model's likelihood
             to talk about new topics. See more information about frequency and
-            presence penalties. (default: :obj:`0.0`)
+            presence penalties. (default: :obj:`None`)
         frequency_penalty (float, optional): Number between :obj:`-2.0` and
             :obj:`2.0`. Positive values penalize new tokens based on their
             existing frequency in the text so far, decreasing the model's
             likelihood to repeat the same line verbatim. See more information
-            about frequency and presence penalties. (default: :obj:`0.0`)
+            about frequency and presence penalties. (default: :obj:`None`)
         logit_bias (dict, optional): Modify the likelihood of specified tokens
             appearing in the completion. Accepts a json object that maps tokens
             (specified by their token ID in the tokenizer) to an associated
@@ -76,7 +76,7 @@ class ChatGPTConfig(BaseConfig):
             The exact effect will vary per model, but values between:obj:` -1`
             and :obj:`1` should decrease or increase likelihood of selection;
             values like :obj:`-100` or :obj:`100` should result in a ban or
-            exclusive selection of the relevant token. (default: :obj:`{}`)
+            exclusive selection of the relevant token. (default: :obj:`None`)
         user (str, optional): A unique identifier representing your end-user,
             which can help OpenAI to monitor and detect abuse.
             (default: :obj:`""`)
@@ -101,21 +101,25 @@ class ChatGPTConfig(BaseConfig):
             :obj:`o1mini`, :obj:`o1preview`, :obj:`o3mini`). If not provided
             or if the model type does not support it, this parameter is
             ignored. (default: :obj:`None`)
+        parallel_tool_calls (bool, optional): A parameter specifying whether
+            the model should call tools in parallel or not. (default:
+            :obj:`None`)
     """
 
-    temperature: float = 0.2  # openai default: 1.0
-    top_p: float = 1.0
-    n: int = 1
-    stream: bool = False
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    n: Optional[int] = None
+    stream: Optional[bool] = None
     stop: Optional[Union[str, Sequence[str]]] = None
     max_tokens: Optional[int] = None
-    presence_penalty: float = 0.0
+    presence_penalty: Optional[float] = None
     response_format: Optional[Union[Type[BaseModel], Dict]] = None
-    frequency_penalty: float = 0.0
-    logit_bias: Dict = Field(default_factory=dict)
-    user: str = ""
+    frequency_penalty: Optional[float] = None
+    logit_bias: Optional[Dict] = None
+    user: Optional[str] = None
     tool_choice: Optional[Union[Dict[str, str], str]] = None
     reasoning_effort: Optional[str] = None
+    parallel_tool_calls: Optional[bool] = None
 
 
 OPENAI_API_PARAMS = {param for param in ChatGPTConfig.model_fields.keys()}