EvoScientist 0.0.1.dev4__py3-none-any.whl → 0.1.0rc1__py3-none-any.whl

EvoScientist/memory.py

@@ -1,715 +0,0 @@
-"""EvoScientist Memory Middleware.
-
-Automatically extracts and persists long-term memory (user profile, research
-preferences, experiment conclusions) from conversations.
-
-Two mechanisms:
-1. **Injection** (every LLM call): Reads ``/memory/MEMORY.md`` and appends it
-   to the system prompt so the agent always has context.
-2. **Extraction** (threshold-triggered): When the conversation exceeds a
-   configurable message count, uses an LLM call to pull out structured facts
-   and merges them into the appropriate MEMORY.md sections.
-
-## Usage
-
-```python
-from EvoScientist.memory import EvoMemoryMiddleware
-
-middleware = EvoMemoryMiddleware(
-    backend=my_backend,          # or backend factory
-    memory_path="/memory/MEMORY.md",
-    extraction_model=chat_model,
-    trigger=("messages", 20),
-)
-agent = create_deep_agent(middleware=[middleware, ...])
-```
-"""
-
-from __future__ import annotations
-
-import logging
-import re
-from collections.abc import Awaitable, Callable
-from contextvars import ContextVar
-from typing import TYPE_CHECKING, Any, Annotated, NotRequired, cast
-
-from langchain.agents.middleware.types import (
-    AgentMiddleware,
-    AgentState,
-    ModelRequest,
-    ModelResponse,
-    PrivateStateAttr,
-)
-from langchain.tools import ToolRuntime
-from langchain_core.messages import AnyMessage, HumanMessage, AIMessage
-from langchain_core.runnables.config import RunnableConfig
-from langgraph.runtime import Runtime
-
-if TYPE_CHECKING:
-    from langchain.chat_models import BaseChatModel
-    from deepagents.backends.protocol import BACKEND_TYPES, BackendProtocol
-
-logger = logging.getLogger(__name__)
-
-_CURRENT_MEMORY: ContextVar[str] = ContextVar("evo_memory_current", default="")
-_STATE_MEMORY_KEY = "evo_memory_content"
-
-
-class EvoMemoryState(AgentState):
-    """State schema for EvoMemoryMiddleware."""
-
-    evo_memory_content: NotRequired[Annotated[str, PrivateStateAttr]]
-
-# ---------------------------------------------------------------------------
-# Extraction prompt – sent to a (cheap) LLM to pull structured facts
-# ---------------------------------------------------------------------------
-
-EXTRACTION_PROMPT = """\
-You are a memory extraction assistant for a scientific experiment agent called EvoScientist.
-
-Analyze the following conversation and extract any NEW information that should be
-remembered long-term. Only extract facts that are **not already present** in the
-current memory shown below.
-
-<current_memory>
-{current_memory}
-</current_memory>
-
-<conversation>
-{conversation}
-</conversation>
-
-Return a JSON object with ONLY the keys that have new information to add.
-Omit keys where there is nothing new. Use `null` for unknown values.
-
-```json
-{{
-  "user_profile": {{
-    "name": "string or null",
-    "role": "string or null",
-    "institution": "string or null",
-    "language": "string or null"
-  }},
-  "research_preferences": {{
-    "primary_domain": "string or null",
-    "sub_fields": "string or null",
-    "preferred_frameworks": "string or null",
-    "preferred_models": "string or null",
-    "hardware": "string or null",
-    "constraints": "string or null"
-  }},
-  "experiment_conclusion": {{
-    "title": "string – experiment name",
-    "question": "string – research question",
-    "method": "string – method summary",
-    "key_result": "string – primary metric/outcome",
-    "conclusion": "string – one-line conclusion",
-    "artifacts": "string – report path if any"
-  }},
-  "learned_preferences": [
-    "string – each new preference or habit observed"
-  ]
-}}
-```
-
-Rules:
-- Only return keys with genuinely new information.
-- If nothing new was found, return an empty JSON object: `{{}}`
-- Do NOT repeat information already in <current_memory>.
-- For experiment_conclusion, only include if a complete experiment was actually run.
-- Be concise. Each value should be a short phrase, not a paragraph.
-"""
-
-# ---------------------------------------------------------------------------
-# System-prompt snippet injected every turn
-# ---------------------------------------------------------------------------
-
-MEMORY_INJECTION_TEMPLATE = """<evo_memory>
-{memory_content}
-</evo_memory>
-
-<memory_instructions>
-The above <evo_memory> contains your long-term memory about the user and past experiments.
-Use this to personalize your responses and avoid re-asking known information.
-
-**When to update memory:**
-- User shares their name, role, institution, or language
-- User mentions their research domain, preferred frameworks, models, or hardware
-- User explicitly asks you to remember something
-- An experiment completes with notable conclusions
-
-**How to update memory:**
-- If /memory/MEMORY.md does not exist yet, use `write_file` to create it
-- If it already exists, use `edit_file` to update specific sections
-- Use this markdown structure:
-
-```markdown
-# EvoScientist Memory
-
-## User Profile
-- **Name**: ...
-- **Role**: ...
-- **Institution**: ...
-- **Language**: ...
-
-## Research Preferences
-- **Primary Domain**: ...
-- **Sub-fields**: ...
-- **Preferred Frameworks**: ...
-- **Preferred Models**: ...
-- **Hardware**: ...
-- **Constraints**: ...
-
-## Experiment History
-### [YYYY-MM-DD] Experiment Title
-- **Question**: ...
-- **Key Result**: ...
-- **Conclusion**: ...
-
-## Learned Preferences
-- ...
-```
-
-**Priority:** Update memory IMMEDIATELY when the user provides personal or research
-information — before composing your main response.
-</memory_instructions>"""
-
-DEFAULT_MEMORY_TEMPLATE = """# EvoScientist Memory
-
-## User Profile
-- **Name**: (unknown)
-- **Role**: (unknown)
-- **Institution**: (unknown)
-- **Language**: (unknown)
-
-## Research Preferences
-- **Primary Domain**: (unknown)
-- **Sub-fields**: (unknown)
-- **Preferred Frameworks**: (unknown)
-- **Preferred Models**: (unknown)
-- **Hardware**: (unknown)
-- **Constraints**: (unknown)
-
-## Experiment History
-(No experiments yet)
-
-## Learned Preferences
-- (none yet)
-"""
-
-
-def _get_thread_id(runtime: Runtime) -> str:
-    try:
-        config = cast("RunnableConfig", getattr(runtime, "config", {}))
-        if isinstance(config, dict):
-            thread_id = config.get("configurable", {}).get("thread_id")
-            if thread_id is not None:
-                return str(thread_id)
-    except Exception:  # noqa: BLE001
-        logger.debug("Failed to resolve thread_id from runtime config")
-    return "default"
-
-
-def _ensure_section(content: str, marker: str, body: str) -> str:
-    if marker in content:
-        return content
-    content = content.rstrip()
-    if content:
-        content += "\n\n"
-    return f"{content}{marker}\n{body.rstrip()}\n"
-
-
-def _ensure_memory_template(existing_md: str) -> str:
-    if not existing_md.strip():
-        return DEFAULT_MEMORY_TEMPLATE
-
-    result = existing_md
-    if "# EvoScientist Memory" not in result:
-        result = "# EvoScientist Memory\n\n" + result.lstrip()
-
-    result = _ensure_section(
-        result,
-        "## User Profile",
-        "\n".join(
-            [
-                "- **Name**: (unknown)",
-                "- **Role**: (unknown)",
-                "- **Institution**: (unknown)",
-                "- **Language**: (unknown)",
-            ],
-        ),
-    )
-    result = _ensure_section(
-        result,
-        "## Research Preferences",
-        "\n".join(
-            [
-                "- **Primary Domain**: (unknown)",
-                "- **Sub-fields**: (unknown)",
-                "- **Preferred Frameworks**: (unknown)",
-                "- **Preferred Models**: (unknown)",
-                "- **Hardware**: (unknown)",
-                "- **Constraints**: (unknown)",
-            ],
-        ),
-    )
-    result = _ensure_section(result, "## Experiment History", "(No experiments yet)")
-    result = _ensure_section(result, "## Learned Preferences", "- (none yet)")
-    return result
-
-
-def _section_bounds(content: str, marker: str) -> tuple[int | None, int | None]:
-    idx = content.find(marker)
-    if idx == -1:
-        return None, None
-    start = idx + len(marker)
-    next_marker = content.find("\n## ", start)
-    if next_marker == -1:
-        next_marker = len(content)
-    return start, next_marker
-
-
-def _normalize_item(value: str) -> str:
-    return re.sub(r"\s+", " ", value.strip().lower())
-
-
-# ---------------------------------------------------------------------------
-# Helper: merge extracted JSON into MEMORY.md markdown
-# ---------------------------------------------------------------------------
-
-def _merge_memory(existing_md: str, extracted: dict[str, Any]) -> str:
-    """Merge extracted fields into the existing MEMORY.md content.
-
-    Performs targeted replacements within the known sections.  Unknown
-    sections or empty extractions are left untouched.
-    """
-    if not extracted:
-        return existing_md
-
-    result = _ensure_memory_template(existing_md)
-
-    # --- User Profile ---
-    profile = extracted.get("user_profile")
-    if profile and isinstance(profile, dict):
-        field_map = {
-            "name": "Name",
-            "role": "Role",
-            "institution": "Institution",
-            "language": "Language",
-        }
-        for key, label in field_map.items():
-            value = profile.get(key)
-            if value and value != "null":
-                # Replace the line  "- **Label**: ..." with new value
-                pattern = rf"(- \*\*{label}\*\*: ).*"
-                replacement = rf"\g<1>{value}"
-                result = re.sub(pattern, replacement, result)
-
-    # --- Research Preferences ---
-    prefs = extracted.get("research_preferences")
-    if prefs and isinstance(prefs, dict):
-        field_map = {
-            "primary_domain": "Primary Domain",
-            "sub_fields": "Sub-fields",
-            "preferred_frameworks": "Preferred Frameworks",
-            "preferred_models": "Preferred Models",
-            "hardware": "Hardware",
-            "constraints": "Constraints",
-        }
-        for key, label in field_map.items():
-            value = prefs.get(key)
-            if value and value != "null":
-                pattern = rf"(- \*\*{label}\*\*: ).*"
-                replacement = rf"\g<1>{value}"
-                result = re.sub(pattern, replacement, result)
-
-    # --- Experiment History (append) ---
-    exp = extracted.get("experiment_conclusion")
-    should_add_exp = bool(exp and isinstance(exp, dict) and exp.get("title"))
-    if should_add_exp:
-        from datetime import datetime
-        date_str = datetime.now().strftime("%Y-%m-%d")
-        title = str(exp.get("title", "Untitled")).strip()
-        entry = f"\n### [{date_str}] {title}\n"
-        entry += f"- **Question**: {exp.get('question', 'N/A')}\n"
-        entry += f"- **Method**: {exp.get('method', 'N/A')}\n"
-        entry += f"- **Key Result**: {exp.get('key_result', 'N/A')}\n"
-        entry += f"- **Conclusion**: {exp.get('conclusion', 'N/A')}\n"
-        if exp.get("artifacts"):
-            entry += f"- **Artifacts**: {exp['artifacts']}\n"
-
-        # Remove placeholder if present
-        exp_start, exp_end = _section_bounds(result, "## Experiment History")
-        if exp_start is not None and exp_end is not None:
-            exp_section = result[exp_start:exp_end]
-            exp_lines = [
-                line for line in exp_section.splitlines() if "(No experiments yet)" not in line
-            ]
-            result = result[:exp_start] + "\n" + "\n".join(exp_lines).strip("\n") + "\n" + result[exp_end:]
-
-        # De-duplicate by title if already present
-        if re.search(rf"### \[[0-9-]+\] {re.escape(title)}\b", result):
-            should_add_exp = False
-
-    if should_add_exp and exp and isinstance(exp, dict) and exp.get("title"):
-        # Insert before "## Learned Preferences"
-        marker = "## Learned Preferences"
-        if marker in result:
-            result = result.replace(marker, entry + "\n" + marker)
-        else:
-            # Fallback: append at end
-            result = result.rstrip() + "\n" + entry
-
-    # --- Learned Preferences (append) ---
-    learned = extracted.get("learned_preferences")
-    if learned and isinstance(learned, list):
-        marker = "## Learned Preferences"
-        start, end = _section_bounds(result, marker)
-        if start is None or end is None:
-            result = _ensure_section(result, marker, "- (none yet)")
-            start, end = _section_bounds(result, marker)
-
-        if start is not None and end is not None:
-            section = result[start:end]
-            section_lines = [
-                line for line in section.splitlines()
-                if line.strip() and line.strip() not in {"- (none yet)", "- (none)"}
-            ]
-            existing_items = {
-                _normalize_item(line[2:])
-                for line in section_lines
-                if line.strip().startswith("- ")
-            }
-            new_lines = []
-            for item in learned:
-                if not item:
-                    continue
-                normalized = _normalize_item(str(item))
-                if normalized in existing_items:
-                    continue
-                existing_items.add(normalized)
-                new_lines.append(f"- {item}")
-
-            if new_lines:
-                section_lines.extend(new_lines)
-                rebuilt = "\n" + "\n".join(section_lines).strip("\n") + "\n"
-                result = result[:start] + rebuilt + result[end:]
-
-    return result
-
-
-# ---------------------------------------------------------------------------
-# Middleware
-# ---------------------------------------------------------------------------
-
-class EvoMemoryMiddleware(AgentMiddleware):
-    """Middleware that injects and auto-extracts long-term memory.
-
-    Args:
-        backend: Backend instance or factory for reading/writing memory files.
-        memory_path: Virtual path to MEMORY.md (default ``/memory/MEMORY.md``).
-        extraction_model: Chat model used for extraction (can be a cheap/fast
-            model like ``claude-haiku``). If ``None``, automatic extraction is
-            disabled and only prompt injection + manual ``edit_file`` works.
-        trigger: When to run automatic extraction.  Supports
-            ``("messages", N)`` to trigger every *N* human messages.
-            Defaults to ``("messages", 20)``.
-    """
-
-    state_schema = EvoMemoryState
-
-    def __init__(
-        self,
-        *,
-        backend: BACKEND_TYPES,
-        memory_path: str = "/memory/MEMORY.md",
-        extraction_model: BaseChatModel | None = None,
-        trigger: tuple[str, int] = ("messages", 20),
-    ) -> None:
-        self._backend = backend
-        self._memory_path = memory_path
-        self._extraction_model = extraction_model
-        self._trigger = trigger
-        self._last_extraction_at: dict[str, int] = {}  # message count per thread
-
-    # -- backend resolution --------------------------------------------------
-
-    def _get_backend(
-        self,
-        state: AgentState[Any],
-        runtime: Runtime,
-    ) -> BackendProtocol:
-        if callable(self._backend):
-            config = cast("RunnableConfig", getattr(runtime, "config", {}))
-            tool_runtime = ToolRuntime(
-                state=state,
-                context=runtime.context,
-                stream_writer=runtime.stream_writer,
-                store=runtime.store,
-                config=config,
-                tool_call_id=None,
-            )
-            return self._backend(tool_runtime)
-        return self._backend
-
-    # -- agent-level preload -------------------------------------------------
-
-    def before_agent(
-        self,
-        state: AgentState[Any],
-        runtime: Runtime,
-        config: RunnableConfig,
-    ) -> dict[str, Any] | None:
-        if state.get(_STATE_MEMORY_KEY) is not None:
-            return None
-        backend = self._get_backend(state, runtime)
-        memory = self._read_memory(backend)
-        _CURRENT_MEMORY.set(memory)
-        return {_STATE_MEMORY_KEY: memory}
-
-    async def abefore_agent(
-        self,
-        state: AgentState[Any],
-        runtime: Runtime,
-        config: RunnableConfig,
-    ) -> dict[str, Any] | None:
-        if state.get(_STATE_MEMORY_KEY) is not None:
-            return None
-        backend = self._get_backend(state, runtime)
-        memory = await self._aread_memory(backend)
-        _CURRENT_MEMORY.set(memory)
-        return {_STATE_MEMORY_KEY: memory}
-
-    # -- read / write helpers ------------------------------------------------
-
-    def _read_memory(self, backend: BackendProtocol) -> str:
-        """Read MEMORY.md content (raw bytes → str)."""
-        try:
-            responses = backend.download_files([self._memory_path])
-            if responses and responses[0].content is not None and responses[0].error is None:
-                return responses[0].content.decode("utf-8")
-        except Exception as e:  # noqa: BLE001
-            logger.debug("Failed to read memory at %s: %s", self._memory_path, e)
-        return ""
-
-    async def _aread_memory(self, backend: BackendProtocol) -> str:
-        try:
-            responses = await backend.adownload_files([self._memory_path])
-            if responses and responses[0].content is not None and responses[0].error is None:
-                return responses[0].content.decode("utf-8")
-        except Exception as e:  # noqa: BLE001
-            logger.debug("Failed to read memory at %s: %s", self._memory_path, e)
-        return ""
-
-    def _write_memory(self, backend: BackendProtocol, old_content: str, new_content: str) -> None:
-        """Write updated MEMORY.md (edit if exists, write if new)."""
-        try:
-            if old_content:
-                result = backend.edit(self._memory_path, old_content, new_content)
-            else:
-                result = backend.write(self._memory_path, new_content)
-            if result and result.error:
-                logger.warning("Failed to write memory: %s", result.error)
-        except Exception as e:  # noqa: BLE001
-            logger.warning("Exception writing memory: %s", e)
-
-    async def _awrite_memory(self, backend: BackendProtocol, old_content: str, new_content: str) -> None:
-        try:
-            if old_content:
-                result = await backend.aedit(self._memory_path, old_content, new_content)
-            else:
-                result = await backend.awrite(self._memory_path, new_content)
-            if result and result.error:
-                logger.warning("Failed to write memory: %s", result.error)
-        except Exception as e:  # noqa: BLE001
-            logger.warning("Exception writing memory: %s", e)
-
-    # -- threshold check -----------------------------------------------------
-
-    def _should_extract(self, thread_id: str, messages: list[AnyMessage]) -> bool:
-        """Check if we should run automatic extraction."""
-        if self._extraction_model is None:
-            return False
-
-        trigger_type, trigger_value = self._trigger
-        if trigger_type == "messages":
-            human_count = sum(1 for m in messages if isinstance(m, HumanMessage))
-            last = self._last_extraction_at.get(thread_id, 0)
-            return (human_count - last) >= trigger_value
-        return False
-
-    # -- extraction ----------------------------------------------------------
-
-    def _extract(self, model: BaseChatModel, memory: str, messages: list[AnyMessage]) -> dict[str, Any]:
-        """Run LLM extraction on recent messages."""
-        import json
-
-        # Build conversation string from recent messages (last 30)
-        recent = messages[-30:]
-        conv_parts = []
-        for msg in recent:
-            if isinstance(msg, HumanMessage):
-                role = "user"
-            elif isinstance(msg, AIMessage):
-                role = "assistant"
-            else:
-                continue
-            content = msg.content if isinstance(msg.content, str) else str(msg.content)
-            conv_parts.append(f"[{role}]: {content}")
-        conversation = "\n".join(conv_parts)
-
-        prompt = EXTRACTION_PROMPT.format(
-            current_memory=memory,
-            conversation=conversation,
-        )
-
-        try:
-            response = model.invoke(prompt)
-            text = response.content if isinstance(response.content, str) else str(response.content)
-            # Extract JSON from response (may be wrapped in ```json ... ```)
-            json_match = re.search(r"```(?:json)?\s*([\s\S]*?)```", text)
-            if json_match:
-                text = json_match.group(1)
-            return json.loads(text.strip())
-        except Exception as e:  # noqa: BLE001
-            logger.warning("Memory extraction failed: %s", e)
-            return {}
-
-    async def _aextract(self, model: BaseChatModel, memory: str, messages: list[AnyMessage]) -> dict[str, Any]:
-        import json
-
-        recent = messages[-30:]
-        conv_parts = []
-        for msg in recent:
-            if isinstance(msg, HumanMessage):
-                role = "user"
-            elif isinstance(msg, AIMessage):
-                role = "assistant"
-            else:
-                continue
-            content = msg.content if isinstance(msg.content, str) else str(msg.content)
-            conv_parts.append(f"[{role}]: {content}")
-        conversation = "\n".join(conv_parts)
-
-        prompt = EXTRACTION_PROMPT.format(
-            current_memory=memory,
-            conversation=conversation,
-        )
-
-        try:
-            response = await model.ainvoke(prompt)
-            text = response.content if isinstance(response.content, str) else str(response.content)
-            json_match = re.search(r"```(?:json)?\s*([\s\S]*?)```", text)
-            if json_match:
-                text = json_match.group(1)
-            return json.loads(text.strip())
-        except Exception as e:  # noqa: BLE001
-            logger.warning("Memory extraction failed: %s", e)
-            return {}
-
-    # -- middleware hooks -----------------------------------------------------
-
-    def modify_request(self, request: ModelRequest) -> ModelRequest:
-        """Inject memory content and instructions into the system message.
-
-        Always injects ``<memory_instructions>`` so the agent knows it can
-        save memories, even when MEMORY.md does not exist yet.
-        """
-        state = request.state or {}
-        memory_content = state.get(_STATE_MEMORY_KEY, "")
-        if not memory_content:
-            memory_content = _CURRENT_MEMORY.get()
-        if not memory_content and request.runtime is not None:
-            try:
-                backend = self._get_backend(state, request.runtime)
-                memory_content = self._read_memory(backend)
-                _CURRENT_MEMORY.set(memory_content)
-            except Exception as e:  # noqa: BLE001
-                logger.debug("Failed to load memory during modify_request: %s", e)
-        # Use placeholder when memory file doesn't exist yet
-        if not memory_content:
-            memory_content = "(No memory saved yet. Create /memory/MEMORY.md when you learn important information.)"
-
-        from deepagents.middleware._utils import append_to_system_message
-        injection = MEMORY_INJECTION_TEMPLATE.format(memory_content=memory_content)
-        new_system = append_to_system_message(request.system_message, injection)
-        return request.override(system_message=new_system)
-
-    def wrap_model_call(
-        self,
-        request: ModelRequest,
-        handler: Callable[[ModelRequest], ModelResponse],
-    ) -> ModelResponse:
-        """Inject memory into system prompt before every LLM call."""
-        modified = self.modify_request(request)
-        return handler(modified)
-
-    async def awrap_model_call(
-        self,
-        request: ModelRequest,
-        handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
-    ) -> ModelResponse:
-        modified = self.modify_request(request)
-        return await handler(modified)
-
-    def before_model(
-        self,
-        state: AgentState[Any],
-        runtime: Runtime,
-    ) -> dict[str, Any] | None:
-        """Read memory and optionally run extraction before each LLM call."""
-        backend = self._get_backend(state, runtime)
-        messages = state["messages"]
-        thread_id = _get_thread_id(runtime)
-
-        # Always read memory for injection
-        memory = self._read_memory(backend)
-        _CURRENT_MEMORY.set(memory)
-        state_update: dict[str, Any] | None = None
-        if state.get(_STATE_MEMORY_KEY) != memory:
-            state_update = {_STATE_MEMORY_KEY: memory}
-
-        # Check extraction threshold
-        if self._should_extract(thread_id, messages):
-            human_count = sum(1 for m in messages if isinstance(m, HumanMessage))
-            extracted = self._extract(self._extraction_model, memory, messages)
-            if extracted:
-                new_memory = _merge_memory(memory, extracted)
-                if new_memory != memory:
-                    self._write_memory(backend, memory, new_memory)
-                    _CURRENT_MEMORY.set(new_memory)
-                    logger.info("Auto-extracted and updated memory")
-                    state_update = {_STATE_MEMORY_KEY: new_memory}
-            self._last_extraction_at[thread_id] = human_count
-
-        return state_update
-
-    async def abefore_model(
-        self,
-        state: AgentState[Any],
-        runtime: Runtime,
-    ) -> dict[str, Any] | None:
-        """Async: Read memory and optionally run extraction."""
-        backend = self._get_backend(state, runtime)
-        messages = state["messages"]
-        thread_id = _get_thread_id(runtime)
-
-        memory = await self._aread_memory(backend)
-        _CURRENT_MEMORY.set(memory)
-        state_update: dict[str, Any] | None = None
-        if state.get(_STATE_MEMORY_KEY) != memory:
-            state_update = {_STATE_MEMORY_KEY: memory}
-
-        if self._should_extract(thread_id, messages):
-            human_count = sum(1 for m in messages if isinstance(m, HumanMessage))
-            extracted = await self._aextract(self._extraction_model, memory, messages)
-            if extracted:
-                new_memory = _merge_memory(memory, extracted)
-                if new_memory != memory:
-                    await self._awrite_memory(backend, memory, new_memory)
-                    _CURRENT_MEMORY.set(new_memory)
-                    logger.info("Auto-extracted and updated memory")
-                    state_update = {_STATE_MEMORY_KEY: new_memory}
-            self._last_extraction_at[thread_id] = human_count
-
-        return state_update