camel-ai 0.2.77__tar.gz → 0.2.78__tar.gz

{camel_ai-0.2.77 → camel_ai-0.2.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.77
+Version: 0.2.78
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -916,6 +916,7 @@ Real-world usecases demonstrating how CAMEL’s multi-agent framework enables re
 |:---|:---|
 | **[ChatDev](https://github.com/OpenBMB/ChatDev/tree/main/camel)** | Communicative Agents for software Development |
 | **[Paper2Poster](https://github.com/Paper2Poster/Paper2Poster)** | Multimodal poster automation from scientific papers |
+| **[Paper2Video](https://github.com/showlab/Paper2Video)** | Automatic video generation from scientific papers |
 
 ### Product Projects
 
@@ -948,6 +949,14 @@ We are actively involved in community events including:
 >
 > We also welcome you to help CAMEL grow by sharing it on social media, at events, or during conferences. Your support makes a big difference!
 
+## Contributors
+
+<a href="https://github.com/camel-ai/camel/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=camel-ai/camel" />
+</a>
+
+Made with [contrib.rocks](https://contrib.rocks).
+
 <br>
 
 ## Community & Contact

{camel_ai-0.2.77 → camel_ai-0.2.78}/README.md

@@ -517,6 +517,7 @@ Real-world usecases demonstrating how CAMEL’s multi-agent framework enables re
 |:---|:---|
 | **[ChatDev](https://github.com/OpenBMB/ChatDev/tree/main/camel)** | Communicative Agents for software Development |
 | **[Paper2Poster](https://github.com/Paper2Poster/Paper2Poster)** | Multimodal poster automation from scientific papers |
+| **[Paper2Video](https://github.com/showlab/Paper2Video)** | Automatic video generation from scientific papers |
 
 ### Product Projects
 
@@ -549,6 +550,14 @@ We are actively involved in community events including:
 >
 > We also welcome you to help CAMEL grow by sharing it on social media, at events, or during conferences. Your support makes a big difference!
 
+## Contributors
+
+<a href="https://github.com/camel-ai/camel/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=camel-ai/camel" />
+</a>
+
+Made with [contrib.rocks](https://contrib.rocks).
+
 <br>
 
 ## Community & Contact

{camel_ai-0.2.77 → camel_ai-0.2.78}/camel/__init__.py

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

{camel_ai-0.2.77 → camel_ai-0.2.78}/camel/agents/chat_agent.py

@@ -30,7 +30,6 @@ import threading
 import time
 import uuid
 import warnings
-from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
 from typing import (
@@ -160,53 +159,6 @@ SIMPLE_FORMAT_PROMPT = TextPrompt(
 )
 
 
-@dataclass
-class _ToolOutputHistoryEntry:
-    tool_name: str
-    tool_call_id: str
-    result_text: str
-    record_uuids: List[str]
-    record_timestamps: List[float]
-    preview_text: str
-    cached: bool = False
-    cache_id: Optional[str] = None
-
-
-class _ToolOutputCacheManager:
-    r"""Minimal persistent store for caching verbose tool outputs."""
-
-    def __init__(self, base_dir: Union[str, Path]) -> None:
-        self.base_dir = Path(base_dir).expanduser().resolve()
-        self.base_dir.mkdir(parents=True, exist_ok=True)
-
-    def save(
-        self,
-        tool_name: str,
-        tool_call_id: str,
-        content: str,
-    ) -> Tuple[str, Path]:
-        cache_id = uuid.uuid4().hex
-        filename = f"{cache_id}.txt"
-        path = self.base_dir / filename
-        header = (
-            f"# Cached tool output\n"
-            f"tool_name: {tool_name}\n"
-            f"tool_call_id: {tool_call_id}\n"
-            f"cache_id: {cache_id}\n"
-            f"---\n"
-        )
-        path.write_text(f"{header}{content}", encoding="utf-8")
-        return cache_id, path
-
-    def load(self, cache_id: str) -> str:
-        path = self.base_dir / f"{cache_id}.txt"
-        if not path.exists():
-            raise FileNotFoundError(
-                f"Cached tool output {cache_id} not found at {path}"
-            )
-        return path.read_text(encoding="utf-8")
-
-
 class StreamContentAccumulator:
     r"""Manages content accumulation across streaming responses to ensure
     all responses contain complete cumulative content."""
@@ -452,19 +404,6 @@ class ChatAgent(BaseAgent):
             usage. When enabled, removes FUNCTION/TOOL role messages and
             ASSISTANT messages with tool_calls after each step.
             (default: :obj:`False`)
-        enable_tool_output_cache (bool, optional): Whether to offload verbose
-            historical tool outputs to a local cache and replace them with
-            lightweight references in memory. Only older tool results whose
-            payload length exceeds ``tool_output_cache_threshold`` are cached.
-            (default: :obj:`False`)
-        tool_output_cache_threshold (int, optional): Minimum character length
-            of a tool result before it becomes eligible for caching. Values
-            below or equal to zero disable caching regardless of the toggle.
-            (default: :obj:`2000`)
-        tool_output_cache_dir (Optional[Union[str, Path]], optional): Target
-            directory for cached tool outputs. When omitted, a ``tool_cache``
-            directory relative to the current working directory is used.
-            (default: :obj:`None`)
         retry_attempts (int, optional): Maximum number of retry attempts for
             rate limit errors. (default: :obj:`3`)
         retry_delay (float, optional): Initial delay in seconds between
@@ -516,9 +455,6 @@ class ChatAgent(BaseAgent):
         mask_tool_output: bool = False,
         pause_event: Optional[Union[threading.Event, asyncio.Event]] = None,
         prune_tool_calls_from_memory: bool = False,
-        enable_tool_output_cache: bool = False,
-        tool_output_cache_threshold: int = 2000,
-        tool_output_cache_dir: Optional[Union[str, Path]] = None,
         retry_attempts: int = 3,
         retry_delay: float = 1.0,
         step_timeout: Optional[float] = None,
@@ -538,28 +474,6 @@ class ChatAgent(BaseAgent):
         # Assign unique ID
         self.agent_id = agent_id if agent_id else str(uuid.uuid4())
 
-        self._tool_output_cache_enabled = (
-            enable_tool_output_cache and tool_output_cache_threshold > 0
-        )
-        self._tool_output_cache_threshold = max(0, tool_output_cache_threshold)
-        self._tool_output_cache_dir: Optional[Path]
-        self._tool_output_cache_manager: Optional[_ToolOutputCacheManager]
-        if self._tool_output_cache_enabled:
-            cache_dir = (
-                Path(tool_output_cache_dir).expanduser()
-                if tool_output_cache_dir is not None
-                else Path("tool_cache")
-            )
-            self._tool_output_cache_dir = cache_dir
-            self._tool_output_cache_manager = _ToolOutputCacheManager(
-                cache_dir
-            )
-        else:
-            self._tool_output_cache_dir = None
-            self._tool_output_cache_manager = None
-        self._tool_output_history: List[_ToolOutputHistoryEntry] = []
-        self._cache_lookup_tool_name = "retrieve_cached_tool_output"
-
         # Set up memory
         context_creator = ScoreBasedContextCreator(
             self.model_backend.token_counter,
@@ -606,8 +520,6 @@ class ChatAgent(BaseAgent):
                 convert_to_function_tool(tool) for tool in (tools or [])
             ]
         }
-        if self._tool_output_cache_enabled:
-            self._ensure_tool_cache_lookup_tool()
 
         # Register agent with toolkits that have RegisteredAgentToolkit mixin
         if toolkits_to_register_agent:
@@ -644,8 +556,6 @@ class ChatAgent(BaseAgent):
         r"""Resets the :obj:`ChatAgent` to its initial state."""
         self.terminated = False
         self.init_messages()
-        if self._tool_output_cache_enabled:
-            self._tool_output_history.clear()
         for terminator in self.response_terminators:
             terminator.reset()
 
@@ -866,178 +776,6 @@ class ChatAgent(BaseAgent):
         for tool in tools:
             self.add_tool(tool)
 
-    def retrieve_cached_tool_output(self, cache_id: str) -> str:
-        r"""Load a cached tool output by its cache identifier.
-
-        Args:
-            cache_id (str): Identifier provided in cached tool messages.
-
-        Returns:
-            str: The cached content or an explanatory error message.
-        """
-        if not self._tool_output_cache_manager:
-            return "Tool output caching is disabled for this agent instance."
-
-        normalized_cache_id = cache_id.strip()
-        if not normalized_cache_id:
-            return "Please provide a non-empty cache_id."
-
-        try:
-            return self._tool_output_cache_manager.load(normalized_cache_id)
-        except FileNotFoundError:
-            return (
-                f"Cache entry '{normalized_cache_id}' was not found. "
-                "Verify the identifier and try again."
-            )
-
-    def _ensure_tool_cache_lookup_tool(self) -> None:
-        if not self._tool_output_cache_enabled:
-            return
-        lookup_name = self._cache_lookup_tool_name
-        if lookup_name in self._internal_tools:
-            return
-        lookup_tool = convert_to_function_tool(
-            self.retrieve_cached_tool_output
-        )
-        self._internal_tools[lookup_tool.get_function_name()] = lookup_tool
-
-    def _serialize_tool_result(self, result: Any) -> str:
-        if isinstance(result, str):
-            return result
-        try:
-            return json.dumps(result, ensure_ascii=False)
-        except (TypeError, ValueError):
-            return str(result)
-
-    def _summarize_tool_result(self, text: str, limit: int = 160) -> str:
-        normalized = re.sub(r"\s+", " ", text).strip()
-        if len(normalized) <= limit:
-            return normalized
-        return normalized[: max(0, limit - 3)].rstrip() + "..."
-
-    def _register_tool_output_for_cache(
-        self,
-        func_name: str,
-        tool_call_id: str,
-        result_text: str,
-        records: List[MemoryRecord],
-    ) -> None:
-        if not records:
-            return
-
-        entry = _ToolOutputHistoryEntry(
-            tool_name=func_name,
-            tool_call_id=tool_call_id,
-            result_text=result_text,
-            record_uuids=[str(record.uuid) for record in records],
-            record_timestamps=[record.timestamp for record in records],
-            preview_text=self._summarize_tool_result(result_text),
-        )
-        self._tool_output_history.append(entry)
-        self._process_tool_output_cache()
-
-    def _process_tool_output_cache(self) -> None:
-        if (
-            not self._tool_output_cache_enabled
-            or not self._tool_output_history
-            or self._tool_output_cache_manager is None
-        ):
-            return
-
-        # Only cache older results; keep the latest expanded for immediate use.
-        for entry in self._tool_output_history[:-1]:
-            if entry.cached:
-                continue
-            if len(entry.result_text) < self._tool_output_cache_threshold:
-                continue
-            self._cache_tool_output_entry(entry)
-
-    def _cache_tool_output_entry(self, entry: _ToolOutputHistoryEntry) -> None:
-        if self._tool_output_cache_manager is None or not entry.record_uuids:
-            return
-
-        try:
-            cache_id, cache_path = self._tool_output_cache_manager.save(
-                entry.tool_name,
-                entry.tool_call_id,
-                entry.result_text,
-            )
-        except Exception as exc:  # pragma: no cover - defensive
-            logger.warning(
-                "Failed to persist cached tool output for %s (%s): %s",
-                entry.tool_name,
-                entry.tool_call_id,
-                exc,
-            )
-            return
-
-        timestamp = (
-            entry.record_timestamps[0]
-            if entry.record_timestamps
-            else time.time_ns() / 1_000_000_000
-        )
-        reference_message = FunctionCallingMessage(
-            role_name=self.role_name,
-            role_type=self.role_type,
-            meta_dict={
-                "cache_id": cache_id,
-                "cached_preview": entry.preview_text,
-                "cached_tool_output_path": str(cache_path),
-            },
-            content="",
-            func_name=entry.tool_name,
-            result=self._build_cache_reference_text(entry, cache_id),
-            tool_call_id=entry.tool_call_id,
-        )
-
-        chat_history_block = getattr(self.memory, "_chat_history_block", None)
-        storage = getattr(chat_history_block, "storage", None)
-        if storage is None:
-            return
-
-        existing_records = storage.load()
-        updated_records = [
-            record
-            for record in existing_records
-            if record["uuid"] not in entry.record_uuids
-        ]
-        new_record = MemoryRecord(
-            message=reference_message,
-            role_at_backend=OpenAIBackendRole.FUNCTION,
-            timestamp=timestamp,
-            agent_id=self.agent_id,
-        )
-        updated_records.append(new_record.to_dict())
-        updated_records.sort(key=lambda record: record["timestamp"])
-        storage.clear()
-        storage.save(updated_records)
-
-        logger.info(
-            "Cached tool output '%s' (%s) to %s with cache_id=%s",
-            entry.tool_name,
-            entry.tool_call_id,
-            cache_path,
-            cache_id,
-        )
-
-        entry.cached = True
-        entry.cache_id = cache_id
-        entry.record_uuids = [str(new_record.uuid)]
-        entry.record_timestamps = [timestamp]
-
-    def _build_cache_reference_text(
-        self, entry: _ToolOutputHistoryEntry, cache_id: str
-    ) -> str:
-        preview = entry.preview_text or "[no preview available]"
-        return (
-            "[cached tool output]\n"
-            f"tool: {entry.tool_name}\n"
-            f"cache_id: {cache_id}\n"
-            f"preview: {preview}\n"
-            f"Use `{self._cache_lookup_tool_name}` with this cache_id to "
-            "retrieve the full content."
-        )
-
     def add_external_tool(
         self, tool: Union[FunctionTool, Callable, Dict[str, Any]]
     ) -> None:
@@ -1082,8 +820,7 @@ class ChatAgent(BaseAgent):
         message: BaseMessage,
         role: OpenAIBackendRole,
         timestamp: Optional[float] = None,
-        return_records: bool = False,
-    ) -> Optional[List[MemoryRecord]]:
+    ) -> None:
         r"""Updates the agent memory with a new message.
 
         If the single *message* exceeds the model's context window, it will
@@ -1103,29 +840,21 @@ class ChatAgent(BaseAgent):
             timestamp (Optional[float], optional): Custom timestamp for the
                 memory record. If `None`, the current time will be used.
                 (default: :obj:`None`)
-            return_records (bool, optional): When ``True`` the method returns
-                the list of :class:`MemoryRecord` objects written to memory.
-                (default: :obj:`False`)
-
-        Returns:
-            Optional[List[MemoryRecord]]: The records that were written when
-            ``return_records`` is ``True``; otherwise ``None``.
+                    (default: obj:`None`)
         """
 
-        written_records: List[MemoryRecord] = []
-
         # 1. Helper to write a record to memory
         def _write_single_record(
             message: BaseMessage, role: OpenAIBackendRole, timestamp: float
         ):
-            record = MemoryRecord(
-                message=message,
-                role_at_backend=role,
-                timestamp=timestamp,
-                agent_id=self.agent_id,
+            self.memory.write_record(
+                MemoryRecord(
+                    message=message,
+                    role_at_backend=role,
+                    timestamp=timestamp,
+                    agent_id=self.agent_id,
+                )
             )
-            written_records.append(record)
-            self.memory.write_record(record)
 
         base_ts = (
             timestamp
@@ -1140,7 +869,7 @@ class ChatAgent(BaseAgent):
             token_limit = context_creator.token_limit
         except AttributeError:
             _write_single_record(message, role, base_ts)
-            return written_records if return_records else None
+            return
 
         # 3. Check if slicing is necessary
         try:
@@ -1156,14 +885,14 @@ class ChatAgent(BaseAgent):
 
             if current_tokens <= remaining_budget:
                 _write_single_record(message, role, base_ts)
-                return written_records if return_records else None
+                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 written_records if return_records else None
+            return
 
         # 4. Perform slicing
         logger.warning(
@@ -1184,18 +913,18 @@ class ChatAgent(BaseAgent):
 
         if not text_to_chunk or not text_to_chunk.strip():
             _write_single_record(message, role, base_ts)
-            return written_records if return_records else None
+            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 written_records if return_records else None
+            return
 
         if not all_token_ids:
             _write_single_record(message, role, base_ts)  # Nothing to chunk
-            return written_records if return_records else None
+            return
 
         # 1.  Base chunk size: one-tenth of the smaller of (a) total token
         # limit and (b) current remaining budget.  This prevents us from
@@ -1261,8 +990,6 @@ class ChatAgent(BaseAgent):
             # Increment timestamp slightly to maintain order
             _write_single_record(new_msg, role, base_ts + i * 1e-6)
 
-        return written_records if return_records else None
-
     def load_memory(self, memory: AgentMemory) -> None:
         r"""Load the provided memory into the agent.
 
@@ -1583,8 +1310,6 @@ class ChatAgent(BaseAgent):
             None
         """
         self.memory.clear()
-        if self._tool_output_cache_enabled:
-            self._tool_output_history.clear()
 
         if self.system_message is not None:
             self.update_memory(self.system_message, OpenAIBackendRole.SYSTEM)
@@ -3015,18 +2740,14 @@ class ChatAgent(BaseAgent):
         base_timestamp = current_time_ns / 1_000_000_000  # Convert to seconds
 
         self.update_memory(
-            assist_msg,
-            OpenAIBackendRole.ASSISTANT,
-            timestamp=base_timestamp,
-            return_records=self._tool_output_cache_enabled,
+            assist_msg, OpenAIBackendRole.ASSISTANT, timestamp=base_timestamp
         )
 
         # Add minimal increment to ensure function message comes after
-        func_records = self.update_memory(
+        self.update_memory(
             func_msg,
             OpenAIBackendRole.FUNCTION,
             timestamp=base_timestamp + 1e-6,
-            return_records=self._tool_output_cache_enabled,
         )
 
         # Record information about this tool call
@@ -3037,20 +2758,6 @@ class ChatAgent(BaseAgent):
             tool_call_id=tool_call_id,
         )
 
-        if (
-            self._tool_output_cache_enabled
-            and not mask_output
-            and func_records
-            and self._tool_output_cache_manager is not None
-        ):
-            serialized_result = self._serialize_tool_result(result)
-            self._register_tool_output_for_cache(
-                func_name,
-                tool_call_id,
-                serialized_result,
-                cast(List[MemoryRecord], func_records),
-            )
-
         return tool_record
 
     def _stream(
@@ -4402,9 +4109,6 @@ class ChatAgent(BaseAgent):
             tool_execution_timeout=self.tool_execution_timeout,
             pause_event=self.pause_event,
             prune_tool_calls_from_memory=self.prune_tool_calls_from_memory,
-            enable_tool_output_cache=self._tool_output_cache_enabled,
-            tool_output_cache_threshold=self._tool_output_cache_threshold,
-            tool_output_cache_dir=self._tool_output_cache_dir,
             stream_accumulate=self.stream_accumulate,
         )
 

{camel_ai-0.2.77 → camel_ai-0.2.78}/camel/toolkits/excel_toolkit.py

@@ -872,7 +872,7 @@ class ExcelToolkit(BaseToolkit):
             import csv
 
             with open(
-                resolved_csv_path, 'w', newline='', encoding='utf-8'
+                resolved_csv_path, 'w', newline='', encoding='utf-8-sig'
             ) as csvfile:
                 writer = csv.writer(csvfile)
                 writer.writerows(data)

{camel_ai-0.2.77 → camel_ai-0.2.78}/camel/toolkits/file_toolkit.py

@@ -906,7 +906,7 @@ class FileToolkit(BaseToolkit):
         self,
         file_path: Path,
         content: Union[str, List[List]],
-        encoding: str = "utf-8",
+        encoding: str = "utf-8-sig",
     ) -> None:
         r"""Write CSV content to a file.
 
@@ -914,7 +914,8 @@ class FileToolkit(BaseToolkit):
             file_path (Path): The target file path.
             content (Union[str, List[List]]): The CSV content as a string or
                 list of lists.
-            encoding (str): Character encoding to use. (default: :obj:`utf-8`)
+            encoding (str): Character encoding to use.
+                (default: :obj:`utf-8-sig`)
         """
         import csv
 

{camel_ai-0.2.77 → camel_ai-0.2.78}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "camel-ai"
-version = "0.2.77"
+version = "0.2.78"
 description = "Communicative Agents for AI Society Study"
 authors = [{ name = "CAMEL-AI.org" }]
 requires-python = ">=3.10,<3.13"
@@ -660,7 +660,7 @@ ignore_missing_imports = true
 # Ref: https://github.com/codespell-project/codespell#using-a-config-file
 # the .py file needs to be listed twice since pre-commit and codespell treat
 # that path differently.
-skip = '.git*,*.pdf,*.svg,*.lock,*.css,examples/toolkits/semantic_scholar_toolkit.py,./examples/toolkits/semantic_scholar_toolkit.py,examples/usecases,./examples/usecases,examples/agents/agent_tool_call_cache.py,./examples/agents/agent_tool_call_cache.py'
+skip = '.git*,*.pdf,*.svg,*.lock,*.css,examples/toolkits/semantic_scholar_toolkit.py,./examples/toolkits/semantic_scholar_toolkit.py,examples/usecases,./examples/usecases'
 check-hidden = true
 # Ignore long lines as usually some kind of base64 encodings e.g. in ipynb
 ignore-regex = '^\s*"image/\S+": ".*|^.{300,}|\b(NotIn|Unsupport)\b'