camel-ai 0.2.67__py3-none-any.whl → 0.2.69a1__py3-none-any.whl

camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.67'
+__version__ = '0.2.69a1'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -54,7 +54,11 @@ from camel.memories import (
     MemoryRecord,
     ScoreBasedContextCreator,
 )
-from camel.messages import BaseMessage, FunctionCallingMessage, OpenAIMessage
+from camel.messages import (
+    BaseMessage,
+    FunctionCallingMessage,
+    OpenAIMessage,
+)
 from camel.models import (
     BaseModelBackend,
     ModelFactory,
@@ -512,27 +516,172 @@ class ChatAgent(BaseAgent):
     ) -> None:
         r"""Updates the agent memory with a new message.
 
+        If the single *message* exceeds the model's context window, it will
+        be **automatically split into multiple smaller chunks** before being
+        written into memory. This prevents later failures in
+        `ScoreBasedContextCreator` where an over-sized message cannot fit
+        into the available token budget at all.
+
+        This slicing logic handles both regular text messages (in the
+        `content` field) and long tool call results (in the `result` field of
+        a `FunctionCallingMessage`).
+
         Args:
             message (BaseMessage): The new message to add to the stored
                 messages.
             role (OpenAIBackendRole): The backend role type.
             timestamp (Optional[float], optional): Custom timestamp for the
-                memory record. If None, current timestamp will be used.
+                memory record. If `None`, the current time will be used.
                 (default: :obj:`None`)
+                    (default: obj:`None`)
         """
+        import math
         import time
+        import uuid as _uuid
+
+        # 1. Helper to write a record to memory
+        def _write_single_record(
+            message: BaseMessage, role: OpenAIBackendRole, timestamp: float
+        ):
+            self.memory.write_record(
+                MemoryRecord(
+                    message=message,
+                    role_at_backend=role,
+                    timestamp=timestamp,
+                    agent_id=self.agent_id,
+                )
+            )
+
+        base_ts = (
+            timestamp
+            if timestamp is not None
+            else time.time_ns() / 1_000_000_000
+        )
+
+        # 2. Get token handling utilities, fallback if unavailable
+        try:
+            context_creator = self.memory.get_context_creator()
+            token_counter = context_creator.token_counter
+            token_limit = context_creator.token_limit
+        except AttributeError:
+            _write_single_record(message, role, base_ts)
+            return
 
-        self.memory.write_record(
-            MemoryRecord(
-                message=message,
-                role_at_backend=role,
-                timestamp=timestamp
-                if timestamp is not None
-                else time.time_ns() / 1_000_000_000,  # Nanosecond precision
-                agent_id=self.agent_id,
+        # 3. Check if slicing is necessary
+        try:
+            current_tokens = token_counter.count_tokens_from_messages(
+                [message.to_openai_message(role)]
+            )
+            _, ctx_tokens = self.memory.get_context()
+            remaining_budget = max(0, token_limit - ctx_tokens)
+
+            if current_tokens <= remaining_budget:
+                _write_single_record(message, role, base_ts)
+                return
+        except Exception as e:
+            logger.warning(
+                f"Token calculation failed before chunking, "
+                f"writing message as-is. Error: {e}"
             )
+            _write_single_record(message, role, base_ts)
+            return
+
+        # 4. Perform slicing
+        logger.warning(
+            f"Message with {current_tokens} tokens exceeds remaining budget "
+            f"of {remaining_budget}. Slicing into smaller chunks."
         )
 
+        text_to_chunk: Optional[str] = None
+        is_function_result = False
+
+        if isinstance(message, FunctionCallingMessage) and isinstance(
+            message.result, str
+        ):
+            text_to_chunk = message.result
+            is_function_result = True
+        elif isinstance(message.content, str):
+            text_to_chunk = message.content
+
+        if not text_to_chunk or not text_to_chunk.strip():
+            _write_single_record(message, role, base_ts)
+            return
+        # Encode the entire text to get a list of all token IDs
+        try:
+            all_token_ids = token_counter.encode(text_to_chunk)
+        except Exception as e:
+            logger.error(f"Failed to encode text for chunking: {e}")
+            _write_single_record(message, role, base_ts)  # Fallback
+            return
+
+        if not all_token_ids:
+            _write_single_record(message, role, base_ts)  # Nothing to chunk
+            return
+
+        # 1.  Base chunk size: one-tenth of the smaller of (a) total token
+        # limit and (b) current remaining budget.  This prevents us from
+        # creating chunks that are guaranteed to overflow the
+        # immediate context window.
+        base_chunk_size = max(1, remaining_budget) // 10
+
+        # 2.  Each chunk gets a textual prefix such as:
+        #        "[chunk 3/12 of a long message]\n"
+        #     The prefix itself consumes tokens, so if we do not subtract its
+        #     length the *total* tokens of the outgoing message (prefix + body)
+        #     can exceed the intended bound.  We estimate the prefix length
+        #     with a representative example that is safely long enough for the
+        #     vast majority of cases (three-digit indices).
+        sample_prefix = "[chunk 1/1000 of a long message]\n"
+        prefix_token_len = len(token_counter.encode(sample_prefix))
+
+        # 3.  The real capacity for the message body is therefore the base
+        #     chunk size minus the prefix length.  Fallback to at least one
+        #     token to avoid zero or negative sizes.
+        chunk_body_limit = max(1, base_chunk_size - prefix_token_len)
+
+        # 4.  Calculate how many chunks we will need with this body size.
+        num_chunks = math.ceil(len(all_token_ids) / chunk_body_limit)
+        group_id = str(_uuid.uuid4())
+
+        for i in range(num_chunks):
+            start_idx = i * chunk_body_limit
+            end_idx = start_idx + chunk_body_limit
+            chunk_token_ids = all_token_ids[start_idx:end_idx]
+
+            chunk_body = token_counter.decode(chunk_token_ids)
+
+            prefix = f"[chunk {i + 1}/{num_chunks} of a long message]\n"
+            new_body = prefix + chunk_body
+
+            if is_function_result and isinstance(
+                message, FunctionCallingMessage
+            ):
+                new_msg: BaseMessage = FunctionCallingMessage(
+                    role_name=message.role_name,
+                    role_type=message.role_type,
+                    meta_dict=message.meta_dict,
+                    content=message.content,
+                    func_name=message.func_name,
+                    args=message.args,
+                    result=new_body,
+                    tool_call_id=message.tool_call_id,
+                )
+            else:
+                new_msg = message.create_new_instance(new_body)
+
+            meta = (new_msg.meta_dict or {}).copy()
+            meta.update(
+                {
+                    "chunk_idx": i + 1,
+                    "chunk_total": num_chunks,
+                    "chunk_group_id": group_id,
+                }
+            )
+            new_msg.meta_dict = meta
+
+            # Increment timestamp slightly to maintain order
+            _write_single_record(new_msg, role, base_ts + i * 1e-6)
+
     def load_memory(self, memory: AgentMemory) -> None:
         r"""Load the provided memory into the agent.
 
@@ -652,9 +801,19 @@ class ChatAgent(BaseAgent):
         r"""Initializes the stored messages list with the current system
         message.
         """
+        import time
+
         self.memory.clear()
+        # avoid UserWarning: The `ChatHistoryMemory` is empty.
         if self.system_message is not None:
-            self.update_memory(self.system_message, OpenAIBackendRole.SYSTEM)
+            self.memory.write_record(
+                MemoryRecord(
+                    message=self.system_message,
+                    role_at_backend=OpenAIBackendRole.SYSTEM,
+                    timestamp=time.time_ns() / 1_000_000_000,
+                    agent_id=self.agent_id,
+                )
+            )
 
     def record_message(self, message: BaseMessage) -> None:
         r"""Records the externally provided message into the agent memory as if

camel/configs/vllm_config.py

@@ -90,6 +90,7 @@ class VLLMConfig(BaseConfig):
             most likely tokens to return at each token position, each with an
             associated log probability. `logprobs` must be set to `true` if
             this parameter is used. (default: :obj:`None`)
+        extra_body: Add additional JSON properties to the request. (default: :obj:`None`)
     """
 
     temperature: Optional[float] = None  # openai default: 1.0
@@ -105,6 +106,7 @@ class VLLMConfig(BaseConfig):
     user: Optional[str] = None
     logprobs: Optional[bool] = None
     top_logprobs: Optional[int] = None
+    extra_body: Optional[dict] = None
 
 
 VLLM_API_PARAMS = {param for param in VLLMConfig.model_fields.keys()}

camel/datagen/self_improving_cot.py

@@ -116,7 +116,7 @@ class SelfImprovingCoTPipeline:
                 samples to be drawn using the rejection sampling
                 method, where samples are accepted or rejected based on
                 a predefined condition to achieve a desired distribution.
-                (default: :obj: `None`)
+                (default: :obj:`None`)
             evaluate_agent (Optional[ChatAgent]): The chat agent used for
                 evaluating reasoning traces. (default: :obj:`None`)
             reward_model (BaseRewardModel, optional): Model used to evaluate

camel/environments/__init__.py

@@ -13,6 +13,13 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from .models import Action, Environment, Observation, StepResult
 from .multi_step import MultiStepEnv
+from .rlcards_env import (
+    ActionExtractor,
+    BlackjackEnv,
+    DoudizhuEnv,
+    LeducHoldemEnv,
+    RLCardsEnv,
+)
 from .single_step import SingleStepEnv
 from .tic_tac_toe import Opponent, TicTacToeEnv
 
@@ -25,4 +32,9 @@ __all__ = [
     "StepResult",
     "TicTacToeEnv",
     "Opponent",
+    "RLCardsEnv",
+    "BlackjackEnv",
+    "LeducHoldemEnv",
+    "ActionExtractor",
+    "DoudizhuEnv",
 ]