refactor(console): decouple chat title refresh from memory abstraction layer (agentscope-ai#7032)

Remove title_refresh_callback from BaseMemoryManager and its concrete
subclasses (ADBPGMemoryManager, ReMeLightMemoryManager). MemoryMiddleware
no longer holds or invokes the callback.

Introduce ChatTitleRefreshMiddleware backed by ChatTitleRefreshService.
The middleware observes conversation lifecycle via on_reply hook, reads
the _auto_memory_flushed context variable set by MemoryMiddleware after
a successful auto-memory flush, and delegates title generation +
compare-and-set persistence to the chat service.

Registered from runtime/builder.py where both chat services and
middleware composition are available, keeping memory backends independent
of chat UI behavior.

Author: Ferrum

src/qwenpaw/agents/memory/adbpg_memory_manager.py

@@ -43,12 +43,10 @@ def __init__(
         self,
         working_dir: str,
         agent_id: str,
-        title_refresh_callback=None,
     ) -> None:
         super().__init__(
             working_dir=working_dir,
             agent_id=agent_id,
-            title_refresh_callback=title_refresh_callback,
         )
         self._adbpg_config = None
         self._client: ADBPGMemoryClient | None = None

src/qwenpaw/agents/memory/base_memory_manager.py

@@ -53,11 +53,9 @@ def __init__(
         self,
         working_dir: str,
         agent_id: str,
-        title_refresh_callback: Callable[..., Awaitable[None]] | None = None,
     ):
         self.working_dir: str = working_dir
         self.agent_id: str = agent_id
-        self.title_refresh_callback = title_refresh_callback
         self._summary_task_info: dict[str, dict[str, Any]] = {}
         self._task_counter: int = 0
         self._task_queue: asyncio.Queue[
@@ -110,7 +108,6 @@ def build_middlewares(self) -> list[MiddlewareBase]:
         return [
             MemoryMiddleware(
                 memory_manager=self,
-                title_refresh_callback=self.title_refresh_callback,
             ),
         ]
 

src/qwenpaw/agents/memory/reme_light_memory_manager.py

@@ -135,12 +135,10 @@ def __init__(
         self,
         working_dir: str,
         agent_id: str,
-        title_refresh_callback=None,
     ):
         super().__init__(
             working_dir=working_dir,
             agent_id=agent_id,
-            title_refresh_callback=title_refresh_callback,
         )
         self._reme: "ReMe | None" = None
         self._reindex_lock = asyncio.Lock()

src/qwenpaw/agents/middlewares.py

@@ -48,6 +48,14 @@
 
 logger = logging.getLogger(__name__)
 MAX_AUTO_MEMORY_TURN_MARKERS = 1000
+
+# Set by MemoryMiddleware._flush_auto_memory() to signal that an auto-memory
+# flush just completed successfully.  ChatTitleRefreshMiddleware reads this
+# in its on_reply hook to decide whether a title refresh is warranted.
+_auto_memory_flushed_var: ContextVar[bool] = ContextVar(
+    "_auto_memory_flushed",
+    default=False,
+)
 AUTO_MEMORY_TURN_STATE_KEY = "qwenpaw_auto_memory_turn_state"
 _AUTOMATION_MEMORY_SKIP_SOURCES = frozenset({"cron", "heartbeat"})
 _TOOL_RESULT_METADATA_KEY = "qwenpaw_tool_result_metadata"
@@ -115,10 +123,8 @@ def __init__(
         self,
         *,
         memory_manager: Any,
-        title_refresh_callback: Callable[..., Awaitable[None]] | None = None,
     ) -> None:
         self._memory_manager = memory_manager
-        self._title_refresh_callback = title_refresh_callback
 
     async def on_system_prompt(
         self,
@@ -364,24 +370,9 @@ async def _flush_auto_memory(
         snapshots = turn_state["snapshots"]
         for marker in submitted:
             snapshots.pop(marker, None)
-        # Best-effort chat title refresh: after a successful auto-memory
-        # flush the conversation has moved on, so regenerate the session
-        # title from this recent slice. Spawned as a background task so it
-        # can never block or break the reply path.
-        callback = self._title_refresh_callback
-        if callback is not None:
-            try:
-                asyncio.create_task(
-                    callback(
-                        agent,
-                        messages,
-                        session_id=self._agent_session_id(agent),
-                    ),
-                )
-            except Exception:
-                logger.exception(
-                    "MemoryMiddleware title refresh scheduling failed",
-                )
+        # Signal ChatTitleRefreshMiddleware that a successful auto-memory
+        # flush just completed.
+        _auto_memory_flushed_var.set(True)
 
     def _discard_unresolved_pending_markers(
         self,
@@ -1021,3 +1012,73 @@ async def on_acting(
                         ],
                     },
                 )
+
+
+class ChatTitleRefreshMiddleware(MiddlewareBase):
+    """Observe conversation lifecycle and refresh chat titles after auto-memory flush.
+
+    This middleware is the sole consumer of the ``_auto_memory_flushed``
+    context variable.  When :meth:`on_reply` detects that an auto-memory
+    flush just completed, it delegates title generation and persistence to
+    the injected :class:`~app.chats.title_refresh_service.ChatTitleRefreshService`.
+
+    Registered from the application/runtime assembly layer (see
+    ``runtime/builder.py``) so that both chat services and middleware
+    composition are available.
+    """
+
+    def __init__(
+        self,
+        *,
+        service: Any,
+        agent_id: str,
+    ) -> None:
+        self._service = service
+        self._agent_id = agent_id
+
+    async def on_reply(
+        self,
+        agent: "Agent",
+        request: Any,
+        next_handler: Any,
+    ) -> AsyncGenerator[Any, Any]:
+        """Wrap each assistant reply turn.
+
+        After the inner handler yields (i.e. the model has produced a full
+        response), check whether auto-memory was flushed this turn.  If so,
+        trigger a title refresh via the dedicated service.
+        """
+        # Run the inner handler to completion first.
+        events: list[Any] = []
+        async for event in next_handler():
+            events.append(event)
+
+        # Only proceed if auto-memory was flushed this turn.
+        if not _auto_memory_flushed_var.get():
+            for ev in events:
+                yield ev
+            return
+
+        # Reset the signal for subsequent turns.
+        _auto_memory_flushed_var.set(False)
+
+        # Gather recent messages from the conversation context.
+        try:
+            from agentscope.message import Msg
+
+            context = list(agent.state.context)
+            recent = [
+                m for m in context if isinstance(m, Msg) and getattr(m, "role", "") == "assistant"
+            ]
+            # Take the last few assistant messages as input for title generation.
+            recent = recent[-3:] if len(recent) >= 3 else recent
+            if recent:
+                await self._service.refresh(
+                    session_id=self._agent_session_id(agent),
+                    recent_messages=recent,
+                )
+        except Exception:
+            logger.exception("ChatTitleRefreshMiddleware.on_reply failed")
+
+        for ev in events:
+            yield ev

src/qwenpaw/app/chats/title_refresh_service.py

@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+"""Chat title refresh service.
+
+Responsible for generating a new title from recent messages and
+persisting it via the chat manager's compare-and-set mechanism.
+This is a pure chat-layer concern — no knowledge of memory backends.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from ...agents.model_factory import _ModelAndFormatter
+    from agentscope.message import Msg
+
+logger = logging.getLogger(__name__)
+
+
+class ChatTitleRefreshService:
+    """Generate chat titles and persist them via compare-and-set.
+
+    Public API::
+
+        async def refresh(
+            session_id: str,
+            recent_messages: list[Msg],
+        ) -> None
+
+    All failures are logged and swallowed so title refresh never breaks
+    the request path.
+    """
+
+    def __init__(
+        self,
+        chat_manager: Any,
+        agent_id: str,
+    ) -> None:
+        self._chat_manager = chat_manager
+        self._agent_id = agent_id
+
+    async def refresh(
+        self,
+        *,
+        session_id: str,
+        recent_messages: list[Any],
+    ) -> None:
+        """Re-generate a chat title from the recent conversation slice.
+
+        Called after each auto-memory flush (see ``ChatTitleRefreshMiddleware``).
+        The chat is located by runtime session id, the recent messages are fed
+        to the LLM for a fresh title, and the name is updated compare-and-set
+        so a user-chosen name is never clobbered.
+        """
+        if not recent_messages:
+            return
+
+        from ...config.config import load_agent_config
+        from ...exceptions import AppBaseException
+
+        try:
+            cfg = load_agent_config(self._agent_id).running
+        except (ValueError, AppBaseException) as exc:
+            logger.info("Auto title refresh skipped: config unavailable (%s)", exc)
+            return
+
+        title_cfg = cfg.auto_title_config
+        if not title_cfg.enabled or not title_cfg.refresh_on_auto_memory:
+            logger.info(
+                "Auto title refresh skipped: refresh_on_auto_memory disabled "
+                "(enabled=%s refresh=%s)",
+                title_cfg.enabled,
+                title_cfg.refresh_on_auto_memory,
+            )
+            return
+
+        chat = await self._chat_manager.find_chat_by_session_id(session_id)
+        if chat is None:
+            logger.info(
+                "Auto title refresh skipped: no chat for session %s",
+                session_id,
+            )
+            return
+
+        chat_id = chat.id
+
+        transcript = _messages_to_text(recent_messages)
+        if not transcript:
+            await self._record(chat_id, ok=False, reason="empty transcript")
+            return
+
+        try:
+            from ...agents.model_factory import create_model_and_formatter
+            from ...utils.model_response import consume_model_response
+            from ..title_generator import REFRESH_TITLE_PROMPT, _clean_title
+            from agentscope.message import Msg, TextBlock
+
+            try:
+                model, _ = create_model_and_formatter(
+                    agent_id=self._agent_id,
+                )
+            except (ValueError, AppBaseException) as exc:
+                logger.info(
+                    "Auto title refresh skipped: no model available for chat %s (%s)",
+                    chat_id,
+                    exc,
+                )
+                await self._record(chat_id, ok=False, reason=f"no model: {exc}")
+                return
+
+            messages = [
+                Msg(
+                    name="system",
+                    role="system",
+                    content=[TextBlock(type="text", text=REFRESH_TITLE_PROMPT)],
+                ),
+                Msg(
+                    name="user",
+                    role="user",
+                    content=[TextBlock(type="text", text=transcript)],
+                ),
+            ]
+
+            raw_title = await asyncio.wait_for(
+                consume_model_response(model, messages),
+                timeout=title_cfg.timeout_seconds,
+            )
+        except Exception:
+            logger.exception(
+                "Auto title refresh LLM failed for chat %s",
+                chat_id,
+            )
+            await self._record(chat_id, ok=False, reason="LLM failed")
+            return
+
+        title = _clean_title(raw_title)
+        if not title:
+            logger.info(
+                "Auto title refresh produced empty output for chat %s",
+                chat_id,
+            )
+            await self._record(chat_id, ok=False, reason="empty LLM output")
+            return
+
+        # Compare-and-set: expected name is the last title we set (or the
+        # current name for chats created before this feature shipped). If the
+        # user renamed the chat manually, the name no longer matches and the
+        # update is skipped.
+        expected_name = chat.meta.get("auto_title_last") or chat.name
+        updated = await self._chat_manager.set_auto_title(
+            chat.id,
+            title,
+            expected_name=expected_name,
+        )
+        if updated is None:
+            logger.info(
+                "Auto title refresh skipped: chat %s renamed manually",
+                chat.id,
+            )
+            await self._record(chat_id, ok=False, reason="renamed manually")
+            return
+        logger.info(
+            "Auto-refreshed chat %s title to %r (session %s)",
+            chat.id,
+            title,
+            session_id,
+        )
+        await self._record(chat_id, ok=True, reason="ok", title=title)
+
+    async def _record(
+        self,
+        chat_id: str,
+        *,
+        ok: bool,
+        reason: str = "",
+        title: str = "",
+    ) -> None:
+        try:
+            await self._chat_manager.record_auto_title_refresh(
+                chat_id,
+                ok=ok,
+                reason=reason,
+                title=title,
+            )
+        except Exception:
+            logger.exception(
+                "Auto title refresh state record failed for chat %s",
+                chat_id,
+            )
+
+
+def _messages_to_text(messages: list[Any]) -> str:
+    """Convert a list of message objects into a plain-text transcript."""
+    parts: list[str] = []
+    for msg in messages:
+        role = getattr(msg, "role", "")
+        content = getattr(msg, "content", "")
+        if isinstance(content, list):
+            # AgentScope 2.0 Msg — extract text blocks
+            for block in content:
+                text = getattr(block, "text", "") or ""
+                if text:
+                    parts.append(f"[{role}] {text}")
+        elif content:
+            parts.append(f"[{role}] {content}")
+    return "\n".join(parts)