aip-agents-binary 0.6.2__py3-none-manylinux_2_31_x86_64.whl → 0.6.4__py3-none-manylinux_2_31_x86_64.whl

aip_agents/agent/base_langgraph_agent.py

@@ -455,6 +455,14 @@ class BaseLangGraphAgent(BaseAgent):
 
         future.add_done_callback(_log_completion)
 
+    def _should_save_interaction(self, final_state: dict[str, Any] | None) -> bool:
+        """Return True when interaction should be saved to memory.
+
+        Subclasses can override this to skip persistence for specific response types.
+        """
+        del final_state
+        return True
+
     def _resolve_and_validate_tools(self) -> list[BaseTool]:
         """Resolve and validate regular tools for LangGraph usage.
 
@@ -898,7 +906,12 @@ class BaseLangGraphAgent(BaseAgent):
             formatted_output = self._format_graph_output(final_state_result)
 
             try:
-                self._memory_save_interaction(user_text=query, ai_text=formatted_output, memory_user_id=memory_user_id)
+                if self._should_save_interaction(final_state_result):
+                    self._memory_save_interaction(
+                        user_text=query,
+                        ai_text=formatted_output,
+                        memory_user_id=memory_user_id,
+                    )
             except Exception:
                 pass
 
@@ -2442,7 +2455,7 @@ class BaseLangGraphAgent(BaseAgent):
                     and isinstance(context.last_final_content, str)
                     and context.last_final_content
                 )
-                if should_save_early:
+                if should_save_early and self._should_save_interaction(context.final_state):
                     try:
                         logger.info(
                             "Agent '%s': A2A persisting memory early (len=%d) for user_id='%s'",
@@ -2461,6 +2474,8 @@ class BaseLangGraphAgent(BaseAgent):
                         context.saved_memory = True
                     except Exception:
                         pass
+                elif should_save_early:
+                    context.saved_memory = True
         except Exception:
             pass
 
@@ -2492,10 +2507,15 @@ class BaseLangGraphAgent(BaseAgent):
                     )
                 except Exception:
                     pass
-                self._memory_save_interaction(
-                    user_text=context.original_query, ai_text=final_text, memory_user_id=context.memory_user_id
-                )
-                context.saved_memory = True
+                if self._should_save_interaction(context.final_state):
+                    self._memory_save_interaction(
+                        user_text=context.original_query,
+                        ai_text=final_text,
+                        memory_user_id=context.memory_user_id,
+                    )
+                    context.saved_memory = True
+                else:
+                    context.saved_memory = True
         except Exception:
             pass
 

aip_agents/agent/langgraph_memory_enhancer_agent.py

@@ -12,7 +12,8 @@ import json
 import textwrap
 from typing import Any
 
-from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+from langchain_core.language_models import BaseChatModel
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, ToolMessage
 from langgraph.graph import END, StateGraph
 from langgraph.graph.state import CompiledStateGraph
 
@@ -20,17 +21,23 @@ from aip_agents.agent.langgraph_react_agent import LangGraphReactAgent
 from aip_agents.agent.system_instruction_context import get_current_date_context
 from aip_agents.memory.guidance import MEM0_MEMORY_RECALL_GUIDANCE
 from aip_agents.tools.memory_search_tool import (
+    MEMORY_DELETE_TOOL_NAME,
     MEMORY_SEARCH_TOOL_NAME,
     LongTermMemorySearchTool,
+    Mem0DeleteTool,
     Mem0SearchTool,
 )
+from aip_agents.utils.langgraph import (
+    convert_langchain_messages_to_gllm_messages,
+    convert_lm_output_to_langchain_message,
+)
 from aip_agents.utils.logger import get_logger
 
 logger = get_logger(__name__)
 
 
 class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
-    """Simplified mini-agent for automatic memory retrieval and query enhancement.
+    """Simplified mini-agent for automatic memory retrieval or deletion and query enhancement.
 
     This agent has a simple 2-node LangGraph (agent + tools) and uses existing memory
     infrastructure to enhance user queries with relevant context. It acts as a
@@ -54,7 +61,12 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
                 - model: LLM model to use for memory decisions
                 - Other BaseLangGraphAgent parameters
         """
-        memory_tool: LongTermMemorySearchTool = Mem0SearchTool(
+        memory_search_tool: LongTermMemorySearchTool = Mem0SearchTool(
+            memory=memory,
+            default_user_id=kwargs.get("memory_agent_id"),
+            user_id_provider=None,
+        )
+        memory_delete_tool: LongTermMemorySearchTool = Mem0DeleteTool(
             memory=memory,
             default_user_id=kwargs.get("memory_agent_id"),
             user_id_provider=None,
@@ -63,7 +75,7 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
         super().__init__(
             name="LangGraphMemoryEnhancerAgent",
             instruction=self._build_simple_instruction(),
-            tools=[memory_tool],
+            tools=[memory_search_tool, memory_delete_tool],
             **kwargs,
         )
 
@@ -78,18 +90,19 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
         instruction = textwrap.dedent(f"""
         {date_context}
 
-        You are a Memory Recall Agent that ONLY decides whether and how to call a memory search tool.
+        You are a Memory Controller Agent that decides whether to retrieve or delete memory.
 
-        Important: You WILL NOT see the tool results. The system will append any retrieved memory
-        to the user input after your turn. Your sole responsibility is to trigger the correct tool
-        calls with concise arguments based on the user's message.
+        Important: You WILL NOT see the tool results. The system will either append retrieved memory
+        to the user input or return a memory action summary after your turn. Your sole responsibility
+        is to trigger the correct tool calls with concise arguments based on the user's message.
 
         What to do:
         1. Read the user's message as-is (do not rephrase it).
-        2. Call the tool `built_in_mem0_search` with minimal, relevant args. Prefer a single call,
-           but you MAY make multiple calls when clearly needed (e.g., separate topics or distinct
-           time ranges). Avoid duplicate or redundant calls.
-           - If the user implies a time frame (e.g., "yesterday", "last week"), set `time_period`.
+        2. Decide which tool to call:
+           - Use `built_in_mem0_search` to retrieve memory for answering questions.
+           - Use `built_in_mem0_delete` when the user asks to forget/delete memories.
+           Prefer a single call, but you MAY make multiple calls when clearly needed.
+           - If the user implies a time frame (e.g., "yesterday", "last week"), set `start_date`/`end_date`.
            - If the user implies a precise range, set `start_date`/`end_date` (YYYY-MM-DD).
            - If the user mentions a topic, set a concise `query` (few words or at most a sentence).
            - Adjust `limit` to higher number to allow more memory to be retrieved if needed.
@@ -110,7 +123,7 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
         return instruction
 
     async def _memory_retrieval_node(self, state: dict, config: dict | None = None) -> dict:
-        """Execute memory retrieval using explicit tool calls or synthesized defaults.
+        """Execute memory retrieval or deletion using explicit tool calls or synthesized defaults.
 
         Args:
             state: LangGraph state containing the conversation `messages` history.
@@ -147,7 +160,7 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
         if not tool_calls:
             return []
 
-        return [tc for tc in tool_calls if tc.get("name") == MEMORY_SEARCH_TOOL_NAME]
+        return [tc for tc in tool_calls if tc.get("name") in {MEMORY_SEARCH_TOOL_NAME, MEMORY_DELETE_TOOL_NAME}]
 
     async def _execute_mem0_tool_calls(
         self,
@@ -166,11 +179,39 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
             List of `ToolMessage` objects describing each execution result.
         """
         tool_messages: list[ToolMessage] = []
+        delete_intent: dict[str, Any] | None = None
+        user_query = self._extract_last_human_query(state.get("messages", [])) or self._fallback_query(
+            state.get("messages", [])
+        )
         for index, tool_call in enumerate(tool_calls):
-            logger.info("Executing memory search tool call #%s with args: %s", index, tool_call.get("args", {}))
-            tool_messages.append(await self._execute_mem0_call(tool_call.get("args", {}), state, config))
+            tool_name = tool_call.get("name") or MEMORY_SEARCH_TOOL_NAME
+            args = dict(tool_call.get("args") or {})
+            if "id" not in args and "id" in tool_call:
+                args["id"] = tool_call["id"]
+            log_args = self._redact_mem0_args(tool_name, args)
+            logger.info("Executing memory tool call #%s name=%s args=%s", index, tool_name, log_args)
+            if tool_name == MEMORY_DELETE_TOOL_NAME:
+                delete_intent = delete_intent or await self._preprocess_delete_intent(user_query, state, config)
+                if not self._is_delete_intent_confirmed(delete_intent):
+                    tool_messages.append(self._build_delete_confirmation_message(tool_call, user_query))
+                    continue
+            tool_messages.append(await self._execute_mem0_call(tool_name, args, state, config))
         return tool_messages
 
+    def _redact_mem0_args(self, tool_name: str, args: dict[str, Any]) -> dict[str, Any]:
+        """Redact sensitive fields from Mem0 tool args before logging."""
+        if tool_name != MEMORY_DELETE_TOOL_NAME:
+            return args
+
+        redacted_args = dict(args)
+        if "memory_ids" in redacted_args:
+            memory_ids = redacted_args.pop("memory_ids")
+            if isinstance(memory_ids, list):
+                redacted_args["memory_ids_count"] = len(memory_ids)
+            else:
+                redacted_args["memory_ids_count"] = 0
+        return redacted_args
+
     async def _execute_default_retrieval(
         self,
         default_query: str | None,
@@ -188,7 +229,7 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
             Single-item list containing the resulting `ToolMessage`.
         """
         args = self._build_default_mem0_args(default_query)
-        tool_message = await self._execute_mem0_call(args, state, config)
+        tool_message = await self._execute_mem0_call(MEMORY_SEARCH_TOOL_NAME, args, state, config)
         return [tool_message]
 
     def _build_default_mem0_args(self, query: str | None) -> dict[str, Any]:
@@ -209,6 +250,7 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
 
     async def _execute_mem0_call(
         self,
+        tool_name: str,
         args: dict[str, Any],
         state: dict,
         config: dict | None,
@@ -216,6 +258,7 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
         """Execute a single Mem0 tool call with metadata resolution.
 
         Args:
+            tool_name: Name of the memory tool to invoke.
             args: Base arguments supplied by the LLM or synthesized defaults.
             state: LangGraph state that may include additional metadata.
             config: Optional runnable configuration forwarded to the tool.
@@ -223,30 +266,30 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
         Returns:
             `ToolMessage` containing raw tool output or an error description.
         """
-        args_with_metadata = self._merge_metadata(args, state)
-        tool_config = self._create_tool_config(config, state, tool_name=MEMORY_SEARCH_TOOL_NAME)
-        mem0_tool = self.resolved_tools[0]
-
+        args_with_metadata = self._merge_metadata(args, state, tool_name)
+        tool_config = self._create_tool_config(config, state, tool_name=tool_name)
         try:
+            mem0_tool = self._get_tool_by_name(tool_name)
             result = await mem0_tool.ainvoke(args_with_metadata, config=tool_config)
             content = str(result)
         except Exception as exc:
-            content = f"Error executing memory search: {exc}"
+            content = f"Error executing memory tool '{tool_name}': {exc}"
 
         return ToolMessage(content=content, tool_call_id=args.get("id", ""))
 
-    def _merge_metadata(self, args: dict[str, Any], state: dict) -> dict[str, Any]:
+    def _merge_metadata(self, args: dict[str, Any], state: dict, tool_name: str) -> dict[str, Any]:
         """Merge resolved metadata into tool arguments.
 
         Args:
             args: Tool arguments that may already include metadata.
             state: LangGraph state providing globally resolved metadata values.
+            tool_name: Name of the tool requesting metadata (used to resolve tool-specific metadata).
 
         Returns:
             Copy of ``args`` containing merged metadata entries.
         """
         args_with_metadata = dict(args)
-        effective_metadata = self._resolve_effective_metadata(state)
+        effective_metadata = self._resolve_effective_metadata(state, tool_name)
         if not effective_metadata:
             return args_with_metadata
 
@@ -259,11 +302,12 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
         args_with_metadata["metadata"] = merged_metadata
         return args_with_metadata
 
-    def _resolve_effective_metadata(self, state: dict) -> dict[str, Any] | None:
+    def _resolve_effective_metadata(self, state: dict, tool_name: str) -> dict[str, Any] | None:
         """Resolve metadata for the Mem0 tool, swallowing resolution errors.
 
         Args:
             state: LangGraph state whose ``metadata`` key may include overrides.
+            tool_name: Name of the tool whose metadata resolution strategy should be used.
 
         Returns:
             Resolved metadata dictionary or ``None`` if not available.
@@ -273,7 +317,7 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
             return None
 
         try:
-            return self._resolve_tool_metadata(MEMORY_SEARCH_TOOL_NAME, raw_metadata)
+            return self._resolve_tool_metadata(tool_name, raw_metadata)
         except Exception:
             return None
 
@@ -309,6 +353,16 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
         """
         messages = state.get("messages", [])
         original_query = self._extract_last_human_query(messages) or self._fallback_query(messages)
+        delete_action = self._extract_delete_action(messages)
+        if delete_action:
+            action_block = self._format_memory_action(delete_action)
+            return {"messages": [AIMessage(content=action_block)]}
+
+        delete_error = self._extract_delete_error(messages)
+        if delete_error:
+            action_block = self._format_memory_action_error(delete_error)
+            return {"messages": [AIMessage(content=action_block)]}
+
         memories = self._collect_unique_memories(messages)
         tagged_memory = self._format_memories(memories)
 
@@ -365,11 +419,13 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
         if not isinstance(message, ToolMessage):
             return []
 
-        raw_results = self._parse_tool_message_content(message)
-        return [memory for memory in raw_results if isinstance(memory, dict)]
+        raw_results = self._parse_tool_message_json(message)
+        if isinstance(raw_results, list):
+            return [memory for memory in raw_results if isinstance(memory, dict)]
+        return []
 
-    def _parse_tool_message_content(self, message: ToolMessage) -> list[Any]:
-        """Parse the JSON content of a tool message into a list.
+    def _parse_tool_message_json(self, message: ToolMessage) -> Any:
+        """Parse the JSON content of a tool message.
 
         Args:
             message: Tool message emitted by the memory search tool.
@@ -385,13 +441,291 @@ class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
                 exc,
                 message.content[:200],
             )
-            return []
-
-        if not isinstance(raw_results, list):
-            return []
+            return None
 
         return raw_results
 
+    def _extract_delete_action(self, messages: list) -> dict[str, Any] | None:
+        """Return delete action details if a delete tool message is present.
+
+        Args:
+            messages: Ordered message history produced during the graph run.
+
+        Returns:
+            Action dict or None when no delete action is detected.
+        """
+        for message in messages:
+            if not isinstance(message, ToolMessage):
+                continue
+            raw_payload = self._parse_tool_message_json(message)
+            if not isinstance(raw_payload, dict):
+                continue
+            status = raw_payload.get("status")
+            if status == "success" and raw_payload.get("mode"):
+                return raw_payload
+            if status == "needs_confirmation":
+                return raw_payload
+        return None
+
+    def _format_memory_action(self, action: dict[str, Any]) -> str:
+        """Format a memory action block for delete results.
+
+        Args:
+            action: Parsed action payload from the delete tool.
+
+        Returns:
+            Formatted action block string.
+        """
+        status = action.get("status", "success")
+        summary = action.get("summary")
+        if status == "needs_confirmation":
+            summary = summary or "Do you want me to delete the related memories?"
+        else:
+            mode = action.get("mode", "unknown")
+            result = action.get("result")
+            summary = summary or f"Deleted memories (mode: {mode})."
+            if isinstance(result, dict):
+                count = result.get("count") or result.get("deleted") or result.get("total")
+                if count is not None:
+                    summary = f"Deleted {count} memories (mode: {mode})."
+        return "\n".join(
+            [
+                "<MEMORY_ACTION>",
+                "action=delete",
+                f"status={status}",
+                f"summary={summary}",
+                "</MEMORY_ACTION>",
+            ]
+        )
+
+    def _extract_delete_error(self, messages: list) -> str | None:
+        """Return delete error summary if delete tool failed.
+
+        Args:
+            messages: Ordered message history produced during the graph run.
+
+        Returns:
+            Error summary string or None when no delete error is detected.
+        """
+        for message in messages:
+            if not isinstance(message, ToolMessage):
+                continue
+            content = message.content if isinstance(message.content, str) else str(message.content)
+            if MEMORY_DELETE_TOOL_NAME in content and "Error" in content:
+                return content[:200]
+        return None
+
+    def _format_memory_action_error(self, error_summary: str) -> str:
+        """Format a memory action block for delete errors."""
+        safe_summary = error_summary.replace("\n", " ").strip()
+        return "\n".join(
+            [
+                "<MEMORY_ACTION>",
+                "action=delete",
+                "status=error",
+                f"summary={safe_summary}",
+                "</MEMORY_ACTION>",
+            ]
+        )
+
+    def _get_tool_by_name(self, tool_name: str) -> Any:
+        """Return the resolved tool instance by name."""
+        for tool in self.resolved_tools:
+            if tool.name == tool_name:
+                return tool
+        raise ValueError(f"Tool '{tool_name}' not found in resolved tools.")
+
+    async def _preprocess_delete_intent(
+        self,
+        query: str | None,
+        state: dict,
+        config: dict | None,
+    ) -> dict[str, Any]:
+        """Run a pre-processing intent check for delete requests.
+
+        Args:
+            query: Latest user query.
+            state: LangGraph state containing metadata for the request.
+            config: Optional runnable configuration forwarded to the model.
+
+        Returns:
+            Normalized intent payload with intent/confidence/reason keys.
+        """
+        if not isinstance(query, str) or not query.strip():
+            return {"intent": "unknown", "confidence": "low", "reason": "empty_query"}
+
+        raw_response = await self._invoke_delete_intent_model(query, state, config)
+        return self._parse_delete_intent_payload(raw_response)
+
+    async def _invoke_delete_intent_model(
+        self,
+        query: str,
+        state: dict,
+        config: dict | None,
+    ) -> str:
+        """Invoke the configured model to classify delete intent.
+
+        Args:
+            query: User query to classify.
+            state: LangGraph state containing request metadata.
+            config: Optional runnable configuration forwarded to the model.
+
+        Returns:
+            Raw model output string, or empty string on failure.
+        """
+        instruction = self._build_delete_intent_instruction()
+        effective_event_emitter = state.get("event_emitter") or self.event_emitter
+        if self.lm_invoker is not None:
+            return await self._invoke_delete_intent_with_invoker(query, instruction, effective_event_emitter)
+
+        if isinstance(self.model, BaseChatModel):
+            return await self._invoke_delete_intent_with_chat_model(query, instruction, config)
+
+        logger.warning("Delete intent check skipped; no model configured.")
+        return ""
+
+    async def _invoke_delete_intent_with_invoker(
+        self,
+        query: str,
+        instruction: str,
+        event_emitter: Any,
+    ) -> str:
+        """Invoke delete intent check using an LM invoker."""
+        messages = convert_langchain_messages_to_gllm_messages([HumanMessage(content=query)], instruction)
+        restore_tools = self.resolved_tools if self.resolved_tools else None
+        if restore_tools is not None:
+            self.lm_invoker.set_tools([])
+        try:
+            lm_output = await self.lm_invoker.invoke(messages=messages, event_emitter=event_emitter)
+        except Exception as exc:
+            logger.warning("Delete intent check failed: %s", exc)
+            return ""
+        finally:
+            if restore_tools is not None:
+                self.lm_invoker.set_tools(restore_tools)
+
+        ai_message = convert_lm_output_to_langchain_message(lm_output)
+        return self._coerce_message_content(ai_message)
+
+    async def _invoke_delete_intent_with_chat_model(
+        self,
+        query: str,
+        instruction: str,
+        config: dict | None,
+    ) -> str:
+        """Invoke delete intent check using a LangChain chat model."""
+        prompt = [SystemMessage(content=instruction), HumanMessage(content=query)]
+        try:
+            ai_message = await self.model.ainvoke(prompt, config)
+        except Exception as exc:
+            logger.warning("Delete intent check failed: %s", exc)
+            return ""
+        return self._coerce_message_content(ai_message)
+
+    def _parse_delete_intent_payload(self, content: str) -> dict[str, Any]:
+        """Parse delete intent payload from model output."""
+        default_payload = {"intent": "unknown", "confidence": "low", "reason": "unparsed"}
+        if not isinstance(content, str) or not content.strip():
+            return default_payload
+
+        payload = self._extract_json_payload(content)
+        if not isinstance(payload, dict):
+            return default_payload
+
+        return self._normalize_delete_intent_payload(payload, default_payload)
+
+    def _extract_json_payload(self, content: str) -> dict[str, Any] | None:
+        """Extract a JSON payload from a raw string."""
+        raw_text = content.strip()
+        if raw_text.startswith("```"):
+            raw_text = raw_text.strip("`")
+            if raw_text.lower().startswith("json"):
+                raw_text = raw_text[4:].strip()
+
+        try:
+            return json.loads(raw_text)
+        except json.JSONDecodeError:
+            start = raw_text.find("{")
+            end = raw_text.rfind("}")
+            if start == -1 or end == -1 or end <= start:
+                return None
+            try:
+                return json.loads(raw_text[start : end + 1])
+            except json.JSONDecodeError:
+                return None
+
+    def _normalize_delete_intent_payload(
+        self,
+        payload: dict[str, Any],
+        default_payload: dict[str, str],
+    ) -> dict[str, Any]:
+        """Normalize payload keys and guard against invalid values."""
+        intent = str(payload.get("intent", "")).lower()
+        confidence = str(payload.get("confidence", "")).lower()
+        if intent not in {"delete", "retrieve", "unknown"}:
+            intent = "unknown"
+        if confidence not in {"high", "medium", "low"}:
+            confidence = "low"
+
+        reason = payload.get("reason")
+        if not isinstance(reason, str):
+            reason = default_payload["reason"]
+
+        return {"intent": intent, "confidence": confidence, "reason": reason}
+
+    @staticmethod
+    def _coerce_message_content(message: AIMessage) -> str:
+        """Normalize AI message content into a string."""
+        content = message.content
+        return content if isinstance(content, str) else str(content)
+
+    def _build_delete_intent_instruction(self) -> str:
+        """Return the system prompt for delete intent classification.
+
+        Design rationale:
+        - Require JSON-only output for deterministic parsing.
+        - Use intent labels (delete|retrieve|unknown) to avoid keyword false positives.
+        - Gate deletion on high confidence to keep ambiguous requests safe.
+
+        Tuning guidance:
+        - Add examples if delete intents are missed.
+        - Adjust confidence thresholds if false negatives become frequent.
+        """
+        return (
+            "You are a memory deletion intent checker. Determine whether the user is asking to "
+            "delete/forget memories stored about them. Reply with JSON only: "
+            '{"intent": "delete|retrieve|unknown", "confidence": "high|medium|low", '
+            '"reason": "short"}. '
+            "If unsure, respond with intent unknown and low confidence."
+        )
+
+    def _is_delete_intent_confirmed(self, decision: dict[str, Any] | None) -> bool:
+        """Return True when delete intent is confirmed by pre-processing."""
+        if not isinstance(decision, dict):
+            logger.warning("Delete intent check failed: decision is not a dict.")
+            return False
+        intent = decision.get("intent")
+        confidence = decision.get("confidence")
+        reason = decision.get("reason", "unknown")
+        if intent != "delete":
+            logger.info("Delete intent not confirmed: intent=%s reason=%s.", intent, reason)
+            return False
+        if confidence != "high":
+            logger.info("Delete intent not confirmed: confidence=%s reason=%s.", confidence, reason)
+            return False
+        return True
+
+    def _build_delete_confirmation_message(self, tool_call: dict[str, Any], query: str | None) -> ToolMessage:
+        """Return a ToolMessage asking for delete confirmation."""
+        summary = "Do you want me to delete the related memories?"
+        if isinstance(query, str) and query.strip():
+            trimmed = query.strip()
+            if len(trimmed) > 160:
+                trimmed = f"{trimmed[:157]}..."
+            summary = f"Do you want me to delete memories related to: '{trimmed}'?"
+        payload = {"status": "needs_confirmation", "summary": summary}
+        return ToolMessage(content=json.dumps(payload), tool_call_id=tool_call.get("id", ""))
+
     def _format_memories(self, memories: list[dict[str, Any]]) -> str:
         """Format memory hits using the underlying tool formatter.
 

aip_agents/agent/langgraph_memory_enhancer_agent.pyi

@@ -2,7 +2,8 @@ from _typeshed import Incomplete
 from aip_agents.agent.langgraph_react_agent import LangGraphReactAgent as LangGraphReactAgent
 from aip_agents.agent.system_instruction_context import get_current_date_context as get_current_date_context
 from aip_agents.memory.guidance import MEM0_MEMORY_RECALL_GUIDANCE as MEM0_MEMORY_RECALL_GUIDANCE
-from aip_agents.tools.memory_search_tool import LongTermMemorySearchTool as LongTermMemorySearchTool, MEMORY_SEARCH_TOOL_NAME as MEMORY_SEARCH_TOOL_NAME, Mem0SearchTool as Mem0SearchTool
+from aip_agents.tools.memory_search_tool import LongTermMemorySearchTool as LongTermMemorySearchTool, MEMORY_DELETE_TOOL_NAME as MEMORY_DELETE_TOOL_NAME, MEMORY_SEARCH_TOOL_NAME as MEMORY_SEARCH_TOOL_NAME, Mem0DeleteTool as Mem0DeleteTool, Mem0SearchTool as Mem0SearchTool
+from aip_agents.utils.langgraph import convert_langchain_messages_to_gllm_messages as convert_langchain_messages_to_gllm_messages, convert_lm_output_to_langchain_message as convert_lm_output_to_langchain_message
 from aip_agents.utils.logger import get_logger as get_logger
 from langgraph.graph import StateGraph
 from langgraph.graph.state import CompiledStateGraph
@@ -10,7 +11,7 @@ from langgraph.graph.state import CompiledStateGraph
 logger: Incomplete
 
 class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
-    """Simplified mini-agent for automatic memory retrieval and query enhancement.
+    """Simplified mini-agent for automatic memory retrieval or deletion and query enhancement.
 
     This agent has a simple 2-node LangGraph (agent + tools) and uses existing memory
     infrastructure to enhance user queries with relevant context. It acts as a