camel-ai 0.2.77__py3-none-any.whl → 0.2.79a0__py3-none-any.whl

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 (
@@ -72,7 +71,6 @@ from camel.memories import (
     MemoryRecord,
     ScoreBasedContextCreator,
 )
-from camel.memories.blocks.chat_history_block import EmptyMemoryWarning
 from camel.messages import (
     BaseMessage,
     FunctionCallingMessage,
@@ -160,53 +158,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 +403,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 +454,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 +473,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 +519,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 +555,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 +775,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 +819,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 +839,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 +868,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:
@@ -1148,22 +876,20 @@ class ChatAgent(BaseAgent):
                 [message.to_openai_message(role)]
             )
 
-            with warnings.catch_warnings():
-                warnings.filterwarnings("ignore", category=EmptyMemoryWarning)
-                _, ctx_tokens = self.memory.get_context()
+            _, 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 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 +910,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 +987,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.
 
@@ -1350,6 +1074,10 @@ class ChatAgent(BaseAgent):
         r"""Summarize the agent's current conversation context and persist it
         to a markdown file.
 
+        .. deprecated:: 0.2.80
+            Use :meth:`asummarize` for async/await support and better
+            performance in parallel summarization workflows.
+
         Args:
             filename (Optional[str]): The base filename (without extension) to
                 use for the markdown file. Defaults to a timestamped name when
@@ -1369,8 +1097,18 @@ class ChatAgent(BaseAgent):
             Dict[str, Any]: A dictionary containing the summary text, file
                 path, status message, and optionally structured_summary if
                 response_format was provided.
+
+        See Also:
+            :meth:`asummarize`: Async version for non-blocking LLM calls.
         """
 
+        warnings.warn(
+            "summarize() is synchronous. Consider using asummarize() "
+            "for async/await support and better performance.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
         result: Dict[str, Any] = {
             "summary": "",
             "file_path": None,
@@ -1520,11 +1258,29 @@ class ChatAgent(BaseAgent):
                 result["status"] = status_message
                 return result
 
-            base_filename = (
-                filename
-                if filename
-                else f"context_summary_{datetime.now().strftime('%Y%m%d_%H%M%S')}"  # noqa: E501
-            )
+            # handle structured output if response_format was provided
+            structured_output = None
+            if response_format and response.msgs[-1].parsed:
+                structured_output = response.msgs[-1].parsed
+
+            # determine filename: use provided filename, or extract from
+            # structured output, or generate timestamp
+            if filename:
+                base_filename = filename
+            elif structured_output and hasattr(
+                structured_output, 'task_title'
+            ):
+                # use task_title from structured output for filename
+                task_title = structured_output.task_title
+                clean_title = ContextUtility.sanitize_workflow_filename(
+                    task_title
+                )
+                base_filename = (
+                    f"{clean_title}_workflow" if clean_title else "workflow"
+                )
+            else:
+                base_filename = f"context_summary_{datetime.now().strftime('%Y%m%d_%H%M%S')}"  # noqa: E501
+
             base_filename = Path(base_filename).with_suffix("").name
 
             metadata = context_util.get_session_metadata()
@@ -1535,11 +1291,274 @@ class ChatAgent(BaseAgent):
                 }
             )
 
-            # Handle structured output if response_format was provided
+            # convert structured output to custom markdown if present
+            if structured_output:
+                # convert structured output to custom markdown
+                summary_content = context_util.structured_output_to_markdown(
+                    structured_data=structured_output, metadata=metadata
+                )
+
+            # Save the markdown (either custom structured or default)
+            save_status = context_util.save_markdown_file(
+                base_filename,
+                summary_content,
+                title="Conversation Summary"
+                if not structured_output
+                else None,
+                metadata=metadata if not structured_output else None,
+            )
+
+            file_path = (
+                context_util.get_working_directory() / f"{base_filename}.md"
+            )
+
+            # Prepare result dictionary
+            result_dict = {
+                "summary": summary_content,
+                "file_path": str(file_path),
+                "status": save_status,
+                "structured_summary": structured_output,
+            }
+
+            result.update(result_dict)
+            logger.info("Conversation summary saved to %s", file_path)
+            return result
+
+        except Exception as exc:
+            error_message = f"Failed to summarize conversation context: {exc}"
+            logger.error(error_message)
+            result["status"] = error_message
+            return result
+
+    async def asummarize(
+        self,
+        filename: Optional[str] = None,
+        summary_prompt: Optional[str] = None,
+        response_format: Optional[Type[BaseModel]] = None,
+        working_directory: Optional[Union[str, Path]] = None,
+    ) -> Dict[str, Any]:
+        r"""Asynchronously summarize the agent's current conversation context
+        and persist it to a markdown file.
+
+        This is the async version of summarize() that uses astep() for
+        non-blocking LLM calls, enabling parallel summarization of multiple
+        agents.
+
+        Args:
+            filename (Optional[str]): The base filename (without extension) to
+                use for the markdown file. Defaults to a timestamped name when
+                not provided.
+            summary_prompt (Optional[str]): Custom prompt for the summarizer.
+                When omitted, a default prompt highlighting key decisions,
+                action items, and open questions is used.
+            response_format (Optional[Type[BaseModel]]): A Pydantic model
+                defining the expected structure of the response. If provided,
+                the summary will be generated as structured output and included
+                in the result.
+            working_directory (Optional[str|Path]): Optional directory to save
+                the markdown summary file. If provided, overrides the default
+                directory used by ContextUtility.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing the summary text, file
+                path, status message, and optionally structured_summary if
+                response_format was provided.
+        """
+
+        result: Dict[str, Any] = {
+            "summary": "",
+            "file_path": None,
+            "status": "",
+        }
+
+        try:
+            # Use external context if set, otherwise create local one
+            if self._context_utility is None:
+                if working_directory is not None:
+                    self._context_utility = ContextUtility(
+                        working_directory=str(working_directory)
+                    )
+                else:
+                    self._context_utility = ContextUtility()
+            context_util = self._context_utility
+
+            # Get conversation directly from agent's memory
+            messages, _ = self.memory.get_context()
+
+            if not messages:
+                status_message = (
+                    "No conversation context available to summarize."
+                )
+                result["status"] = status_message
+                return result
+
+            # Convert messages to conversation text
+            conversation_lines = []
+            for message in messages:
+                role = message.get('role', 'unknown')
+                content = message.get('content', '')
+
+                # Handle tool call messages (assistant calling tools)
+                tool_calls = message.get('tool_calls')
+                if tool_calls and isinstance(tool_calls, (list, tuple)):
+                    for tool_call in tool_calls:
+                        # Handle both dict and object formats
+                        if isinstance(tool_call, dict):
+                            func_name = tool_call.get('function', {}).get(
+                                'name', 'unknown_tool'
+                            )
+                            func_args_str = tool_call.get('function', {}).get(
+                                'arguments', '{}'
+                            )
+                        else:
+                            # Handle object format (Pydantic or similar)
+                            func_name = getattr(
+                                getattr(tool_call, 'function', None),
+                                'name',
+                                'unknown_tool',
+                            )
+                            func_args_str = getattr(
+                                getattr(tool_call, 'function', None),
+                                'arguments',
+                                '{}',
+                            )
+
+                        # Parse and format arguments for readability
+                        try:
+                            import json
+
+                            args_dict = json.loads(func_args_str)
+                            args_formatted = ', '.join(
+                                f"{k}={v}" for k, v in args_dict.items()
+                            )
+                        except (json.JSONDecodeError, ValueError, TypeError):
+                            args_formatted = func_args_str
+
+                        conversation_lines.append(
+                            f"[TOOL CALL] {func_name}({args_formatted})"
+                        )
+
+                # Handle tool response messages
+                elif role == 'tool':
+                    tool_name = message.get('name', 'unknown_tool')
+                    if not content:
+                        content = str(message.get('content', ''))
+                    conversation_lines.append(
+                        f"[TOOL RESULT] {tool_name} → {content}"
+                    )
+
+                # Handle regular content messages (user/assistant/system)
+                elif content:
+                    conversation_lines.append(f"{role}: {content}")
+
+            conversation_text = "\n".join(conversation_lines).strip()
+
+            if not conversation_text:
+                status_message = (
+                    "Conversation context is empty; skipping summary."
+                )
+                result["status"] = status_message
+                return result
+
+            if self._context_summary_agent is None:
+                self._context_summary_agent = ChatAgent(
+                    system_message=(
+                        "You are a helpful assistant that summarizes "
+                        "conversations"
+                    ),
+                    model=self.model_backend,
+                    agent_id=f"{self.agent_id}_context_summarizer",
+                )
+            else:
+                self._context_summary_agent.reset()
+
+            if summary_prompt:
+                prompt_text = (
+                    f"{summary_prompt.rstrip()}\n\n"
+                    f"AGENT CONVERSATION TO BE SUMMARIZED:\n"
+                    f"{conversation_text}"
+                )
+            else:
+                prompt_text = (
+                    "Summarize the context information in concise markdown "
+                    "bullet points highlighting key decisions, action items.\n"
+                    f"Context information:\n{conversation_text}"
+                )
+
+            try:
+                # Use structured output if response_format is provided
+                if response_format:
+                    response = await self._context_summary_agent.astep(
+                        prompt_text, response_format=response_format
+                    )
+                else:
+                    response = await self._context_summary_agent.astep(
+                        prompt_text
+                    )
+
+                # Handle streaming response
+                if isinstance(response, AsyncStreamingChatAgentResponse):
+                    # Collect final response
+                    final_response = await response
+                    response = final_response
+
+            except Exception as step_exc:
+                error_message = (
+                    f"Failed to generate summary using model: {step_exc}"
+                )
+                logger.error(error_message)
+                result["status"] = error_message
+                return result
+
+            if not response.msgs:
+                status_message = (
+                    "Failed to generate summary from model response."
+                )
+                result["status"] = status_message
+                return result
+
+            summary_content = response.msgs[-1].content.strip()
+            if not summary_content:
+                status_message = "Generated summary is empty."
+                result["status"] = status_message
+                return result
+
+            # handle structured output if response_format was provided
             structured_output = None
             if response_format and response.msgs[-1].parsed:
                 structured_output = response.msgs[-1].parsed
-                # Convert structured output to custom markdown
+
+            # determine filename: use provided filename, or extract from
+            # structured output, or generate timestamp
+            if filename:
+                base_filename = filename
+            elif structured_output and hasattr(
+                structured_output, 'task_title'
+            ):
+                # use task_title from structured output for filename
+                task_title = structured_output.task_title
+                clean_title = ContextUtility.sanitize_workflow_filename(
+                    task_title
+                )
+                base_filename = (
+                    f"{clean_title}_workflow" if clean_title else "workflow"
+                )
+            else:
+                base_filename = f"context_summary_{datetime.now().strftime('%Y%m%d_%H%M%S')}"  # noqa: E501
+
+            base_filename = Path(base_filename).with_suffix("").name
+
+            metadata = context_util.get_session_metadata()
+            metadata.update(
+                {
+                    "agent_id": self.agent_id,
+                    "message_count": len(messages),
+                }
+            )
+
+            # convert structured output to custom markdown if present
+            if structured_output:
+                # convert structured output to custom markdown
                 summary_content = context_util.structured_output_to_markdown(
                     structured_data=structured_output, metadata=metadata
                 )
@@ -1583,8 +1602,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)
@@ -1622,7 +1639,7 @@ class ChatAgent(BaseAgent):
         message.
         """
         self.memory.clear()
-        # avoid UserWarning: The `ChatHistoryMemory` is empty.
+        # Write system message to memory if provided
         if self.system_message is not None:
             self.memory.write_record(
                 MemoryRecord(
@@ -3015,18 +3032,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 +3050,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 +4401,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,
         )