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

camel/interpreters/docker/Dockerfile

@@ -55,11 +55,8 @@ RUN curl -fsSL https://install.python-poetry.org | python3.10 - && \
 # Upgrade pip and install base Python packages
 RUN python3.10 -m pip install --upgrade pip setuptools wheel
 
-# Install uv
-RUN curl -LsSf https://astral.sh/uv/install.sh | sh && \
-    mv /root/.local/bin/uv /usr/local/bin/uv && \
-    mv /root/.local/bin/uvx /usr/local/bin/uvx && \
-    chmod +x /usr/local/bin/uv /usr/local/bin/uvx
+# Install uv using pip instead of the shell script
+RUN pip install uv
 
 # Setup working directory
 WORKDIR /workspace

camel/loaders/firecrawl_reader.py

@@ -98,8 +98,8 @@ class Firecrawl:
     def scrape(
         self,
         url: str,
-        params: Optional[Dict[str, Any]] = None,
-    ) -> Dict:
+        params: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, str]:
         r"""To scrape a single URL. This function supports advanced scraping
         by setting different parameters and returns the full scraped data as a
         dictionary.
@@ -108,11 +108,11 @@ class Firecrawl:
 
         Args:
             url (str): The URL to read.
-            params (Optional[Dict[str, Any]]): Additional parameters for the
+            params (Optional[Dict[str, str]]): Additional parameters for the
                 scrape request.
 
         Returns:
-            Dict: The scraped data.
+            Dict[str, str]: The scraped data.
 
         Raises:
             RuntimeError: If the scrape process fails.

camel/memories/blocks/vectordb_block.py

@@ -89,13 +89,20 @@ class VectorDBBlock(MemoryBlock):
             records (List[MemoryRecord]): Memory records to be added to the
                 memory.
         """
+        # Filter out records with empty message content
+        valid_records = [
+            record
+            for record in records
+            if record.message.content and record.message.content.strip()
+        ]
+
         v_records = [
             VectorRecord(
                 vector=self.embedding.embed(record.message.content),
                 payload=record.to_dict(),
                 id=str(record.uuid),
             )
-            for record in records
+            for record in valid_records
         ]
         self.storage.add(v_records)
 

camel/memories/context_creators/score_based.py

@@ -11,14 +11,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-from typing import List, Optional, Tuple
+from collections import defaultdict
+from typing import Dict, List, Optional, Tuple
 
 from pydantic import BaseModel
 
 from camel.logger import get_logger
 from camel.memories.base import BaseContextCreator
 from camel.memories.records import ContextRecord
-from camel.messages import OpenAIMessage
+from camel.messages import FunctionCallingMessage, OpenAIMessage
 from camel.types.enums import OpenAIBackendRole
 from camel.utils import BaseTokenCounter
 
@@ -74,6 +75,8 @@ class ScoreBasedContextCreator(BaseContextCreator):
         3. Final output maintains chronological order and in history memory,
            the score of each message decreases according to keep_rate. The
            newer the message, the higher the score.
+        4. Tool calls and their responses are kept together to maintain
+           API compatibility
 
         Args:
             records (List[ContextRecord]): List of context records with scores
@@ -110,6 +113,11 @@ class ScoreBasedContextCreator(BaseContextCreator):
 
         # Process non-system messages with deduplication
         for idx, record in enumerate(records):
+            if (
+                record.memory_record.role_at_backend
+                == OpenAIBackendRole.SYSTEM
+            ):
+                continue
             if record.memory_record.uuid in seen_uuids:
                 continue
             seen_uuids.add(record.memory_record.uuid)
@@ -126,12 +134,17 @@ class ScoreBasedContextCreator(BaseContextCreator):
             )
 
         # ======================
-        # 3. Token Calculation
+        # 3. Tool Call Relationship Mapping
+        # ======================
+        tool_call_groups = self._group_tool_calls_and_responses(regular_units)
+
+        # ======================
+        # 4. Token Calculation
         # ======================
         total_tokens = system_tokens + sum(u.num_tokens for u in regular_units)
 
         # ======================
-        # 4. Early Return if Within Limit
+        # 5. Early Return if Within Limit
         # ======================
         if total_tokens <= self.token_limit:
             sorted_units = sorted(
@@ -140,7 +153,7 @@ class ScoreBasedContextCreator(BaseContextCreator):
             return self._assemble_output(sorted_units, system_unit)
 
         # ======================
-        # 5. Truncation Logic
+        # 6. Truncation Logic with Tool Call Awareness
         # ======================
         logger.warning(
             f"Context truncation required "
@@ -148,24 +161,12 @@ class ScoreBasedContextCreator(BaseContextCreator):
             f"pruning low-score messages."
         )
 
-        # Sort for truncation: high scores first, older messages first at same
-        # score
-        sorted_for_truncation = sorted(
-            regular_units, key=self._truncation_sort_key
+        remaining_units = self._truncate_with_tool_call_awareness(
+            regular_units, tool_call_groups, system_tokens
         )
 
-        # Reverse to process from lowest score (end of sorted list)
-        remaining_units = []
-        current_total = system_tokens
-
-        for unit in sorted_for_truncation:
-            potential_total = current_total + unit.num_tokens
-            if potential_total <= self.token_limit:
-                remaining_units.append(unit)
-                current_total = potential_total
-
         # ======================
-        # 6. Output Assembly
+        # 7. Output Assembly
         # ======================
 
         # In case system message is the only message in memory when sorted
@@ -180,6 +181,170 @@ class ScoreBasedContextCreator(BaseContextCreator):
         final_units = sorted(remaining_units, key=self._conversation_sort_key)
         return self._assemble_output(final_units, system_unit)
 
+    def _group_tool_calls_and_responses(
+        self, units: List[_ContextUnit]
+    ) -> Dict[str, List[_ContextUnit]]:
+        r"""Groups tool calls with their corresponding responses based on
+        `tool_call_id`.
+
+        This improved logic robustly gathers all messages (assistant requests
+        and tool responses, including chunks) that share a `tool_call_id`.
+
+        Args:
+            units (List[_ContextUnit]): List of context units to analyze.
+
+        Returns:
+            Dict[str, List[_ContextUnit]]: Mapping from `tool_call_id` to a
+                list of related units.
+        """
+        tool_call_groups: Dict[str, List[_ContextUnit]] = defaultdict(list)
+
+        for unit in units:
+            # FunctionCallingMessage stores tool_call_id.
+            message = unit.record.memory_record.message
+            tool_call_id = getattr(message, 'tool_call_id', None)
+
+            if tool_call_id:
+                tool_call_groups[tool_call_id].append(unit)
+
+        # Filter out empty or incomplete groups if necessary,
+        # though defaultdict and getattr handle this gracefully.
+        return dict(tool_call_groups)
+
+    def _truncate_with_tool_call_awareness(
+        self,
+        regular_units: List[_ContextUnit],
+        tool_call_groups: Dict[str, List[_ContextUnit]],
+        system_tokens: int,
+    ) -> List[_ContextUnit]:
+        r"""Truncates messages while preserving tool call-response pairs.
+        This method implements a more sophisticated truncation strategy:
+        1. It treats tool call groups (request + responses) and standalone
+           messages as individual items to be included.
+        2. It sorts all items by score and greedily adds them to the context.
+        3. **Partial Truncation**: If a complete tool group is too large to
+        fit,it attempts to add the request message and as many of the most
+        recent response chunks as the token budget allows.
+
+        Args:
+            regular_units (List[_ContextUnit]): All regular message units.
+            tool_call_groups (Dict[str, List[_ContextUnit]]): Grouped tool
+                calls.
+            system_tokens (int): Tokens used by the system message.
+
+        Returns:
+            List[_ContextUnit]: A list of units that fit within the token
+                limit.
+        """
+
+        # Create a set for quick lookup of units belonging to any tool call
+        tool_call_unit_ids = {
+            unit.record.memory_record.uuid
+            for group in tool_call_groups.values()
+            for unit in group
+        }
+
+        # Separate standalone units from tool call groups
+        standalone_units = [
+            u
+            for u in regular_units
+            if u.record.memory_record.uuid not in tool_call_unit_ids
+        ]
+
+        # Prepare all items (standalone units and groups) for sorting
+        all_potential_items: List[Dict] = []
+        for unit in standalone_units:
+            all_potential_items.append(
+                {
+                    "type": "standalone",
+                    "score": unit.record.score,
+                    "timestamp": unit.record.timestamp,
+                    "tokens": unit.num_tokens,
+                    "item": unit,
+                }
+            )
+        for group in tool_call_groups.values():
+            all_potential_items.append(
+                {
+                    "type": "group",
+                    "score": max(u.record.score for u in group),
+                    "timestamp": max(u.record.timestamp for u in group),
+                    "tokens": sum(u.num_tokens for u in group),
+                    "item": group,
+                }
+            )
+
+        # Sort all potential items by score (high to low), then timestamp
+        all_potential_items.sort(key=lambda x: (-x["score"], -x["timestamp"]))
+
+        remaining_units: List[_ContextUnit] = []
+        current_tokens = system_tokens
+
+        for item_dict in all_potential_items:
+            item_type = item_dict["type"]
+            item = item_dict["item"]
+            item_tokens = item_dict["tokens"]
+
+            if current_tokens + item_tokens <= self.token_limit:
+                # The whole item (standalone or group) fits, so add it
+                if item_type == "standalone":
+                    remaining_units.append(item)
+                else:  # item_type == "group"
+                    remaining_units.extend(item)
+                current_tokens += item_tokens
+
+            elif item_type == "group":
+                # The group does not fit completely; try partial inclusion.
+                request_unit: Optional[_ContextUnit] = None
+                response_units: List[_ContextUnit] = []
+
+                for unit in item:
+                    # Assistant msg with `args` is the request
+                    if (
+                        isinstance(
+                            unit.record.memory_record.message,
+                            FunctionCallingMessage,
+                        )
+                        and unit.record.memory_record.message.args is not None
+                    ):
+                        request_unit = unit
+                    else:
+                        response_units.append(unit)
+
+                # A group must have a request to be considered for inclusion.
+                if request_unit is None:
+                    continue
+
+                # Check if we can at least fit the request.
+                if (
+                    current_tokens + request_unit.num_tokens
+                    <= self.token_limit
+                ):
+                    units_to_add = [request_unit]
+                    tokens_to_add = request_unit.num_tokens
+
+                    # Sort responses by timestamp to add newest chunks first
+                    response_units.sort(
+                        key=lambda u: u.record.timestamp, reverse=True
+                    )
+
+                    for resp_unit in response_units:
+                        if (
+                            current_tokens
+                            + tokens_to_add
+                            + resp_unit.num_tokens
+                            <= self.token_limit
+                        ):
+                            units_to_add.append(resp_unit)
+                            tokens_to_add += resp_unit.num_tokens
+
+                    # A request must be followed by at least one response
+                    if len(units_to_add) > 1:
+                        remaining_units.extend(units_to_add)
+                        current_tokens += tokens_to_add
+
+        return remaining_units
+
     def _extract_system_message(
         self, records: List[ContextRecord]
     ) -> Tuple[Optional[_ContextUnit], List[_ContextUnit]]:
@@ -215,25 +380,6 @@ class ScoreBasedContextCreator(BaseContextCreator):
         )
         return system_message_unit, []
 
-    def _truncation_sort_key(self, unit: _ContextUnit) -> Tuple[float, float]:
-        r"""Defines the sorting key for the truncation phase.
-
-        Sorting priority:
-        - Primary: Sort by score in descending order (higher scores first).
-        - Secondary: Sort by timestamp in ascending order (older messages
-            first when scores are equal).
-
-        Args:
-            unit (_ContextUnit): A `_ContextUnit` representing a conversation
-                record.
-
-        Returns:
-            Tuple[float, float]:
-            - Negative score for descending order sorting.
-            - Timestamp for ascending order sorting.
-        """
-        return (-unit.record.score, unit.record.timestamp)
-
     def _conversation_sort_key(
         self, unit: _ContextUnit
     ) -> Tuple[float, float]:

camel/models/anthropic_model.py

@@ -12,11 +12,14 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, List, Optional, Union
+
+from openai import AsyncStream, Stream
 
 from camel.configs import ANTHROPIC_API_PARAMS, AnthropicConfig
+from camel.messages import OpenAIMessage
 from camel.models.openai_compatible_model import OpenAICompatibleModel
-from camel.types import ModelType
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
 from camel.utils import (
     AnthropicTokenCounter,
     BaseTokenCounter,
@@ -25,6 +28,47 @@ from camel.utils import (
 )
 
 
+def strip_trailing_whitespace_from_messages(
+    messages: List[OpenAIMessage],
+) -> List[OpenAIMessage]:
+    r"""Strip trailing whitespace from all message contents in a list of
+    messages. This is necessary because the Anthropic API doesn't allow
+    trailing whitespace in message content.
+
+    Args:
+        messages (List[OpenAIMessage]): List of messages to process
+
+    Returns:
+        List[OpenAIMessage]: The processed messages with trailing whitespace
+            removed
+    """
+    if not messages:
+        return messages
+
+    # Create a deep copy to avoid modifying the original messages
+    processed_messages = [dict(msg) for msg in messages]
+
+    # Process each message
+    for msg in processed_messages:
+        if "content" in msg and msg["content"] is not None:
+            if isinstance(msg["content"], str):
+                msg["content"] = msg["content"].rstrip()
+            elif isinstance(msg["content"], list):
+                # Handle content that's a list of content parts (e.g., for
+                # multimodal content)
+                for i, part in enumerate(msg["content"]):
+                    if (
+                        isinstance(part, dict)
+                        and "text" in part
+                        and isinstance(part["text"], str)
+                    ):
+                        part["text"] = part["text"].rstrip()
+                    elif isinstance(part, str):
+                        msg["content"][i] = part.rstrip()
+
+    return processed_messages  # type: ignore[return-value]
+
+
 class AnthropicModel(OpenAICompatibleModel):
     r"""Anthropic API in a unified OpenAICompatibleModel interface.
 
@@ -89,6 +133,9 @@ class AnthropicModel(OpenAICompatibleModel):
             **kwargs,
         )
 
+        # Monkey patch the AnthropicTokenCounter to handle trailing whitespace
+        self._patch_anthropic_token_counter()
+
     @property
     def token_counter(self) -> BaseTokenCounter:
         r"""Initialize the token counter for the model backend.
@@ -115,3 +162,68 @@ class AnthropicModel(OpenAICompatibleModel):
                     f"Unexpected argument `{param}` is "
                     "input into Anthropic model backend."
                 )
+
+    def _request_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        # Strip trailing whitespace from all message contents to prevent
+        # Anthropic API errors
+        processed_messages = strip_trailing_whitespace_from_messages(messages)
+
+        # Call the parent class method
+        return super()._request_chat_completion(processed_messages, tools)
+
+    async def _arequest_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        # Strip trailing whitespace from all message contents to prevent
+        # Anthropic API errors
+        processed_messages = strip_trailing_whitespace_from_messages(messages)
+
+        # Call the parent class method
+        return await super()._arequest_chat_completion(
+            processed_messages, tools
+        )
+
+    def _patch_anthropic_token_counter(self):
+        r"""Monkey patch the AnthropicTokenCounter class to handle trailing
+        whitespace.
+
+        This patches the count_tokens_from_messages method to strip trailing
+        whitespace from message content before sending to the Anthropic API.
+        """
+        import functools
+
+        from anthropic.types import MessageParam
+
+        from camel.utils import AnthropicTokenCounter
+
+        original_count_tokens = (
+            AnthropicTokenCounter.count_tokens_from_messages
+        )
+
+        @functools.wraps(original_count_tokens)
+        def patched_count_tokens(self, messages):
+            # Process messages to remove trailing whitespace
+            processed_messages = strip_trailing_whitespace_from_messages(
+                messages
+            )
+
+            # Use the processed messages with the original method
+            return self.client.messages.count_tokens(
+                messages=[
+                    MessageParam(
+                        content=str(msg["content"]),
+                        role="user" if msg["role"] == "user" else "assistant",
+                    )
+                    for msg in processed_messages
+                ],
+                model=self.model,
+            ).input_tokens
+
+        # Apply the monkey patch
+        AnthropicTokenCounter.count_tokens_from_messages = patched_count_tokens

camel/runtimes/configs.py

@@ -21,22 +21,22 @@ class TaskConfig(BaseModel):
 
     Arttributes:
         cmd (str or list): Command to be executed
-        stdout (bool): Attach to stdout. (default: :obj: `True`)
-        stderr (bool): Attach to stderr. (default: :obj: `True`)
-        stdin (bool): Attach to stdin. (default: :obj: `False`)
-        tty (bool): Allocate a pseudo-TTY. (default: :obj: `False`)
-        privileged (bool): Run as privileged. (default: :obj: `False`)
-        user (str): User to execute command as. (default: :obj: `""`)
+        stdout (bool): Attach to stdout. (default: :obj:`True`)
+        stderr (bool): Attach to stderr. (default: :obj:`True`)
+        stdin (bool): Attach to stdin. (default: :obj:`False`)
+        tty (bool): Allocate a pseudo-TTY. (default: :obj:`False`)
+        privileged (bool): Run as privileged. (default: :obj:`False`)
+        user (str): User to execute command as. (default: :obj:`""`)
         detach (bool): If true, detach from the exec command.
-            (default: :obj: `False`)
-        stream (bool): Stream response data. (default: :obj: `False`)
+            (default: :obj:`False`)
+        stream (bool): Stream response data. (default: :obj:`False`)
         socket (bool): Return the connection socket to allow custom
-            read/write operations. (default: :obj: `False`)
+            read/write operations. (default: :obj:`False`)
         environment (dict or list): A dictionary or a list of strings in
             the following format ``["PASSWORD=xxx"]`` or
-            ``{"PASSWORD": "xxx"}``. (default: :obj: `None`)
+            ``{"PASSWORD": "xxx"}``. (default: :obj:`None`)
         workdir (str): Path to working directory for this exec session.
-            (default: :obj: `None`)
+            (default: :obj:`None`)
         demux (bool): Return stdout and stderr separately. (default: :obj:
             `False`)
     """

camel/runtimes/daytona_runtime.py

@@ -34,13 +34,13 @@ class DaytonaRuntime(BaseRuntime):
     Args:
         api_key (Optional[str]): The Daytona API key for authentication. If not
             provided, it will try to use the DAYTONA_API_KEY environment
-            variable. (default: :obj: `None`)
+            variable. (default: :obj:`None`)
         api_url (Optional[str]): The URL of the Daytona server. If not
             provided, it will try to use the DAYTONA_API_URL environment
             variable. If none is provided, it will use "http://localhost:8000".
-            (default: :obj: `None`)
+            (default: :obj:`None`)
         language (Optional[str]): The programming language for the sandbox.
-            (default: :obj: `"python"`)
+            (default: :obj:`"python"`)
     """
 
     def __init__(
@@ -102,7 +102,7 @@ class DaytonaRuntime(BaseRuntime):
                 list of functions to add.
             entrypoint (str): The entrypoint for the function.
             arguments (Optional[Dict[str, Any]]): The arguments for the
-                function. (default: :obj: `None`)
+                function. (default: :obj:`None`)
 
         Returns:
             DaytonaRuntime: The current runtime.

camel/runtimes/docker_runtime.py

@@ -45,7 +45,7 @@ class DockerRuntime(BaseRuntime):
         port (int): The port number to use for the runtime API. (default: :obj:
             `8000`)
         remove (bool): Whether to remove the container after stopping it. '
-            (default: :obj: `True`)
+            (default: :obj:`True`)
         kwargs (dict): Additional keyword arguments to pass to the
             Docker client.
     """
@@ -170,7 +170,7 @@ class DockerRuntime(BaseRuntime):
 
         Args:
             time_out (int): The number of seconds to wait for the container to
-                start. (default: :obj: `15`)
+                start. (default: :obj:`15`)
 
         Returns:
             DockerRuntime: The DockerRuntime instance.
@@ -259,9 +259,9 @@ class DockerRuntime(BaseRuntime):
                 list of functions to add.
             entrypoint (str): The entrypoint for the function.
             redirect_stdout (bool): Whether to return the stdout of
-                the function. (default: :obj: `False`)
+                the function. (default: :obj:`False`)
             arguments (Optional[Dict[str, Any]]): The arguments for the
-                function. (default: :obj: `None`)
+                function. (default: :obj:`None`)
 
         Returns:
             DockerRuntime: The DockerRuntime instance.
@@ -330,7 +330,7 @@ class DockerRuntime(BaseRuntime):
 
         Args:
             remove (Optional[bool]): Whether to remove the container
-                after stopping it. (default: :obj: `None`)
+                after stopping it. (default: :obj:`None`)
 
         Returns:
             DockerRuntime: The DockerRuntime instance.
@@ -366,7 +366,7 @@ class DockerRuntime(BaseRuntime):
         r"""Wait for the API Server to be ready.
 
         Args:
-            timeout (int): The number of seconds to wait. (default: :obj: `10`)
+            timeout (int): The number of seconds to wait. (default: :obj:`10`)
 
         Returns:
             bool: Whether the API Server is ready.

camel/runtimes/remote_http_runtime.py

@@ -36,9 +36,9 @@ class RemoteHttpRuntime(BaseRuntime):
 
     Args:
         host (str): The host of the remote server.
-        port (int): The port of the remote server. (default: :obj: `8000`)
+        port (int): The port of the remote server. (default: :obj:`8000`)
         python_exec (str): The python executable to run the API server.
-            (default: :obj: `python3`)
+            (default: :obj:`python3`)
     """
 
     def __init__(
@@ -90,9 +90,9 @@ class RemoteHttpRuntime(BaseRuntime):
                 list of functions to add.
             entrypoint (str): The entrypoint for the function.
             redirect_stdout (bool): Whether to return the stdout of
-                the function. (default: :obj: `False`)
+                the function. (default: :obj:`False`)
             arguments (Optional[Dict[str, Any]]): The arguments for the
-                function. (default: :obj: `None`)
+                function. (default: :obj:`None`)
 
         Returns:
             RemoteHttpRuntime: The current runtime.
@@ -162,7 +162,7 @@ class RemoteHttpRuntime(BaseRuntime):
         r"""Wait for the API Server to be ready.
 
         Args:
-            timeout (int): The number of seconds to wait. (default: :obj: `10`)
+            timeout (int): The number of seconds to wait. (default: :obj:`10`)
 
         Returns:
             bool: Whether the API Server is ready.