langchain-agentx-python 1.0.5__tar.gz → 1.0.8__tar.gz

{langchain-agentx-python-1.0.5 → langchain-agentx-python-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-agentx-python
-Version: 1.0.5
+Version: 1.0.8
 Summary: LangChain/LangGraph-based agent utilities for CodeBaseX.
 Author-email: GoodMood2008 <GoodMood2008@users.noreply.github.com>
 License:                                  Apache License

{langchain-agentx-python-1.0.5 → langchain-agentx-python-1.0.8}/langchain_agentx/__init__.py

@@ -11,7 +11,7 @@ from langchain_agentx import create_loop_agent
 ```
 """
 
-__version__ = "1.0.5"
+__version__ = "1.0.8"
 
 from .loop import (  # noqa: F401
     create_loop_agent,

{langchain-agentx-python-1.0.5 → langchain-agentx-python-1.0.8}/langchain_agentx/loop/config/loop_config.py

@@ -251,6 +251,7 @@ class AgentLoopConfig:
     # -----------------------------------------------------------------------
     task_notification_max_priority: QueuePriority = QueuePriority.NEXT
     managed_rules: str | None = None
+    claude_md_excludes: tuple[str, ...] = ()
 
     # -----------------------------------------------------------------------
     # 模型 profile

{langchain-agentx-python-1.0.5 → langchain-agentx-python-1.0.8}/langchain_agentx/loop/context/query_source.py

@@ -1,16 +1,16 @@
 """
-query_source.py — Query Source 单一来源与 Loop 守卫策略
+query_source 守卫策略（Compaction / Fork / UI 路由）。
 
 职责：
-    定义所有 query_source 官方常量，并提供 autocompact / microcompact /
-    token_blocking / persist_replacements 的统一跳过判定。
+    autocompact / microcompact / token_blocking / persist_replacements 的统一跳过判定。
 
 链路位置：
     ForkedAgentRunner / Loop 编译 → QuerySourcePolicy.compile_loop_context()
     → ContextCompactionContext / CompactionSettings / model_node 守卫。
 
 当前裁剪范围：
-    不实现 fork 执行与 Coordinator 触发；仅提供常量与策略判定基座。
+    常量定义在 loop.exit.query_source（对齐 CC constants/querySource.ts）；
+    本模块仅承载与 compaction 相关的策略类。
 """
 
 from __future__ import annotations
@@ -18,6 +18,8 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Final, FrozenSet, Literal
 
+from langchain_agentx.loop.exit.query_source import QuerySource
+
 CompactionGuardStage = Literal[
     "autocompact",
     "microcompact",
@@ -27,40 +29,6 @@ CompactionGuardStage = Literal[
 
 EmitterRoute = Literal["main", "sidechain", "drop"]
 
-
-class QuerySource:
-    """官方 query_source 常量（禁止在业务代码散落字面量）。"""
-
-    MAIN_THREAD: Final[str] = "main_thread"
-    EXTRACT_MEMORIES: Final[str] = "extract_memories"
-    SESSION_MEMORY: Final[str] = "session_memory"
-    COMPACT: Final[str] = "compact"
-    AGENT_SUMMARY: Final[str] = "agent_summary"
-    AGENT_PREFIX: Final[str] = "agent:"
-
-    @classmethod
-    def all_official(cls) -> FrozenSet[str]:
-        return frozenset(
-            {
-                cls.MAIN_THREAD,
-                cls.EXTRACT_MEMORIES,
-                cls.SESSION_MEMORY,
-                cls.COMPACT,
-                cls.AGENT_SUMMARY,
-            }
-        )
-
-    @classmethod
-    def is_agent_subagent(cls, query_source: str | None) -> bool:
-        return isinstance(query_source, str) and query_source.startswith(cls.AGENT_PREFIX)
-
-    @classmethod
-    def normalize(cls, query_source: str | None) -> str:
-        if isinstance(query_source, str) and query_source.strip():
-            return query_source.strip()
-        return cls.MAIN_THREAD
-
-
 # 后台 fork 任务：跳过 autocompact / microcompact
 _BACKGROUND_COMPACTION_SKIP: Final[FrozenSet[str]] = frozenset(
     {
@@ -142,6 +110,14 @@ class QuerySourcePolicy:
             persist_replacements=cls.should_persist_replacements(normalized),
         )
 
+    @classmethod
+    def is_main_repl_thread(cls, query_source: str | None) -> bool:
+        """对齐 CC querySource === 'repl_main_thread'；缺省 / None 视为 main。"""
+        normalized = QuerySource.normalize(query_source)
+        if normalized == QuerySource.MAIN_THREAD:
+            return True
+        return normalized == "repl_main_thread" or normalized.startswith("repl_main_thread:")
+
     @classmethod
     def default_ui_visible(cls, query_source: str | None) -> bool:
         normalized = QuerySource.normalize(query_source)

{langchain-agentx-python-1.0.5 → langchain-agentx-python-1.0.8}/langchain_agentx/loop/exit/exit_logic.py

@@ -25,6 +25,8 @@ from typing import Any, NotRequired, TypedDict
 
 from langchain_core.messages import AIMessage
 
+from .query_source import QuerySource
+
 from .resolution import LoopResolution
 from .terminal import LoopTerminal
 
@@ -219,6 +221,7 @@ def create_initial_state(
         "finish_reason": None,
         "finish_reasons": [],
         "section_cache": {},
+        "query_source": QuerySource.MAIN_THREAD,
     }
 
 
@@ -264,6 +267,7 @@ class AgentLoopState(TypedDict):
     finish_reason: str | None  # Provider 协议层：这一轮 completion 为何停
     finish_reasons: list[str]  # finish_reason 历史（观测用）
     section_cache: dict[str, str | None]  # SystemPromptSection session 级缓存（key=name, value=compute() 结果）
+    query_source: NotRequired[str]  # Loop 来源标签；主 REPL 为 main_thread，Fork 子图透传
 
 
 # 状态字段契约别名（对外统一使用 LoopAgentStateFields）

langchain-agentx-python-1.0.8/langchain_agentx/loop/exit/query_source.py

@@ -0,0 +1,54 @@
+"""
+query_source 官方常量（对齐 CC constants/querySource.ts）。
+
+职责：
+    Loop 来源标签的单一字面量来源；与 compaction / fork 策略解耦。
+
+链路位置：
+    AgentLoopState 默认值（exit_logic）与各层通过 query_source 字段透传。
+
+当前裁剪范围：
+    仅常量与 normalize；守卫策略见 loop.context.query_source.QuerySourcePolicy。
+"""
+
+from __future__ import annotations
+
+from typing import Final, FrozenSet
+
+
+class QuerySource:
+    """官方 query_source 常量（禁止在业务代码散落字面量）。"""
+
+    MAIN_THREAD: Final[str] = "main_thread"
+    EXTRACT_MEMORIES: Final[str] = "extract_memories"
+    SESSION_MEMORY: Final[str] = "session_memory"
+    COMPACT: Final[str] = "compact"
+    AGENT_SUMMARY: Final[str] = "agent_summary"
+    MEMDIR_RELEVANCE: Final[str] = "memdir_relevance"
+    AGENT_PREFIX: Final[str] = "agent:"
+
+    @classmethod
+    def all_official(cls) -> FrozenSet[str]:
+        return frozenset(
+            {
+                cls.MAIN_THREAD,
+                cls.EXTRACT_MEMORIES,
+                cls.SESSION_MEMORY,
+                cls.COMPACT,
+                cls.AGENT_SUMMARY,
+                cls.MEMDIR_RELEVANCE,
+            }
+        )
+
+    @classmethod
+    def is_agent_subagent(cls, query_source: str | None) -> bool:
+        return isinstance(query_source, str) and query_source.startswith(cls.AGENT_PREFIX)
+
+    @classmethod
+    def normalize(cls, query_source: str | None) -> str:
+        if isinstance(query_source, str) and query_source.strip():
+            return query_source.strip()
+        return cls.MAIN_THREAD
+
+
+__all__ = ["QuerySource"]

{langchain-agentx-python-1.0.5 → langchain-agentx-python-1.0.8}/langchain_agentx/loop/graph/factory.py

@@ -89,10 +89,6 @@ from ...memory.instruction.runtime import (
     CallbackActiveFilesProvider,
     InstructionMemoryBootstrap,
 )
-from ...memory.memdir.agent_memory import (
-    AgentMemoryPromptBootstrap,
-    get_default_agent_memory_extraction_coordinator,
-)
 from ...memory.memdir.runtime import MemoryPromptBootstrap
 from ...memory.memdir.extractor import MemoryExtractionCoordinator
 from ...memory.memdir.paths import is_memory_enabled
@@ -101,7 +97,6 @@ from ..hook.post_sample_hook import PostSampleHook
 # SessionMemoryCompactBridge uses lazy import to avoid circular dependency with memory.session.session_memory
 from ..prompt import SystemPromptSection, build_effective_system_prompt
 from ..prompt.session_context import get_default_session_context_sections
-from ...tools.agent.prompt import build_explore_plan_guidance
 from ..config import ModelContextResolver
 from ..config.loop_config import (
     AgentLoopConfig,
@@ -352,6 +347,7 @@ class LoopGraphBuilder:
         self._state_schema = state_schema
         self._context_schema = context_schema
         self._prepared = False
+        self._memory_prefetch_coordinator: Any | None = None
 
     def _prepare_compile_context(self) -> None:
         if self._prepared:
@@ -369,7 +365,16 @@ class LoopGraphBuilder:
         self._dynamic_sections: list[SystemPromptSection] = list(self._config.prompt.dynamic_sections)
         append_system_prompt = self._config.prompt.append_system
         self._resolve_workspace_config()
-        self._setup_loader_tools()
+        self._setup_loader_tools(
+            session_store=session_store,
+            model=model,
+            schema_cache_namespace=session_id or "",
+        )
+        from ...loop.prompt.tool_aware_sections import (
+            build_tool_aware_prompt_sections,
+        )
+
+        runtime_tools = getattr(self, "_runtime_tools", None) or []
         # P0-3: 初始化 session_store.cwd
         # 从 config.workspace.runtime_cwd 或回退到 workspace_root
         if session_store is not None and hasattr(session_store, "set_cwd"):
@@ -405,10 +410,20 @@ class LoopGraphBuilder:
             from ...memory.session.compact_bridge import SessionMemoryCompactBridge
 
             session_memory_path = self._workspace_cfg.session_memory_path(session_id)
+            session_memory_extractor = None
+            if not self._config.subagent.is_subagent:
+                session_memory_extractor = self._build_session_memory_extractor(
+                    model=model,
+                    session_store=session_store,
+                    session_id=session_id or "",
+                    session_memory_path=session_memory_path,
+                    base_prompt=base_prompt,
+                )
             self._session_memory_manager = SessionMemoryManager(
                 session_memory_path=session_memory_path,
                 llm=model,
                 is_subagent=self._config.subagent.is_subagent,
+                extractor=session_memory_extractor,
             )
             self._session_memory_compact_bridge = SessionMemoryCompactBridge(
                 session_memory_path=session_memory_path,
@@ -432,6 +447,7 @@ class LoopGraphBuilder:
                 workspace_root=Path(self._workspace_root),
                 agent_home_segment=self._agent_home_segment,
                 managed_rules=self._config.managed_rules,
+                claude_md_excludes=self._config.claude_md_excludes,
                 active_files_provider=(
                     CallbackActiveFilesProvider(self._services.active_files_getter)
                     if self._services.active_files_getter is not None
@@ -446,14 +462,15 @@ class LoopGraphBuilder:
                 available_tools=self._loader_tools,
             ).build_sections()
         )
-        self._dynamic_sections.extend(
-            AgentMemoryPromptBootstrap(
-                workspace_cfg=self._workspace_cfg,
-                is_subagent=self._config.subagent.is_subagent,
-                subagent_type=self._config.subagent.subagent_type,
-                available_tools=self._loader_tools,
-            ).build_sections()
-        )
+        if not self._config.subagent.is_subagent:
+            self._dynamic_sections.extend(
+                build_tool_aware_prompt_sections(
+                    self._enabled_tool_names,
+                    runtime_tools=runtime_tools,
+                    include_session_memory_mechanics=self._config.enable_session_memory,
+                    is_subagent=False,
+                )
+            )
         system_message = self._build_system_message(
             base_prompt=base_prompt,
             append_system_prompt=append_system_prompt,
@@ -467,12 +484,6 @@ class LoopGraphBuilder:
         self._built_in_tools = []
         self._available_tools = list(self._loader_tools)
 
-        if not self._config.subagent.is_subagent:
-            append_system_prompt, system_message = self._apply_explore_guidance(
-                append_system_prompt=append_system_prompt,
-                base_prompt=base_prompt,
-            )
-
         # 使用已有的 config（frozen，不可修改），但需要添加运行时计算的值
         # 运行时需要的额外值存储在 self._* 字段中
 
@@ -553,17 +564,21 @@ class LoopGraphBuilder:
             model=model,
             session_store=session_store,
             session_id=session_id or "",
+            trace_collector=collector,
+        )
+        self._memory_prefetch_coordinator = self._build_memory_prefetch_coordinator(
+            model=model,
+            session_store=session_store,
         )
         self._hook_graph_wiring = HookGraphWiring(
             hook_engine,
             trace_lifecycle_collector=trace_lifecycle_collector,
             session_memory=self._session_memory_manager,
             memory_extractor=memory_extractor,
-            agent_memory_extractor=get_default_agent_memory_extraction_coordinator(),
+            memory_prefetch_coordinator=self._memory_prefetch_coordinator,
             workspace_cfg=self._workspace_cfg,
             session_id=session_id or "",
             container_type=container_type,
-            subagent_type=self._config.subagent.subagent_type,
             post_sample_hook=PostSampleHook(memory_extractor=memory_extractor),
         )
         if self._config.trace.enabled:
@@ -632,8 +647,17 @@ class LoopGraphBuilder:
         if self._services.prompt_handler is not None:
             loader.set_prompt_handler(self._services.prompt_handler)
 
-    def _setup_loader_tools(self) -> None:
+    def _setup_loader_tools(
+        self,
+        *,
+        session_store: Any | None = None,
+        model: Any | None = None,
+        schema_cache_namespace: str | None = None,
+    ) -> None:
         self._loader_tools = []
+        self._runtime_tools = []
+        self._tool_prompt_ctx = None
+        self._enabled_tool_names = frozenset()
         self._skill_runtime_tool = None
         self._loop_loader = None
         if self._services.loader is not None:
@@ -653,20 +677,76 @@ class LoopGraphBuilder:
             for tool in self._services.loader.registry.list():
                 if tool.name not in self._loop_loader.registry._tools:
                     self._loop_loader.register(tool)
-            self._loader_tools = self._loop_loader.registry.to_langchain_tools()
-            for rt in self._loop_loader.registry.list():
+            self._runtime_tools = self._loop_loader.registry.list()
+            from ...loop.prompt.tool_aware_sections import collect_enabled_tool_names
+
+            self._enabled_tool_names = collect_enabled_tool_names(self._runtime_tools)
+            self._tool_prompt_ctx = self._build_tool_prompt_context(
+                session_store=session_store,
+                model=model,
+                schema_cache_namespace=schema_cache_namespace,
+            )
+            self._loader_tools = self._loop_loader.registry.to_langchain_tools(
+                prompt_ctx=self._tool_prompt_ctx,
+            )
+            for rt in self._runtime_tools:
                 if self._skill_runtime_tool is None and rt.__class__.__name__ == "SkillRuntimeTool":
                     self._skill_runtime_tool = rt
 
+    def _resolve_policy_config(self) -> Any | None:
+        loader = self._loop_loader or self._services.loader
+        if loader is None:
+            return None
+        policy_cfg = getattr(loader, "policy_config", None)
+        if policy_cfg is None and hasattr(loader, "_process"):
+            policy_cfg = getattr(loader._process, "policy_config", None)
+        return policy_cfg
+
+    def _snapshot_permission_context(
+        self,
+        *,
+        session_store: Any | None = None,
+    ) -> Any:
+        from ...tool_runtime.permission_snapshot import build_permission_snapshot
+
+        return build_permission_snapshot(
+            permission_mode=self._config.permission_mode,
+            policy_config=self._resolve_policy_config(),
+            session_store=session_store,
+        )
+
+    def _build_tool_prompt_context(
+        self,
+        *,
+        session_store: Any | None = None,
+        model: Any | None = None,
+        schema_cache_namespace: str | None = None,
+    ) -> Any:
+        from ...tool_runtime.prompt_context import build_tool_prompt_context
+
+        resolved_model = model if model is not None else self._config.model
+        model_name = getattr(resolved_model, "model_name", None)
+        return build_tool_prompt_context(
+            runtime_tools=self._runtime_tools,
+            enabled_tool_names=self._enabled_tool_names,
+            permission_snapshot=self._snapshot_permission_context(session_store=session_store),
+            workspace_cfg=getattr(self, "_workspace_cfg", None),
+            headless=self._config.headless,
+            model_name=model_name,
+            schema_cache_namespace=schema_cache_namespace,
+        )
+
     def _build_memory_extraction_coordinator(
         self,
         *,
         model: Any,
         session_store: Any,
         session_id: str,
+        trace_collector: Any | None = None,
     ) -> MemoryExtractionCoordinator:
         from ..subagent.context import ForkedParentRuntime
         from ..subagent.forked_runner import ForkedAgentRunner
+        from ...memory.memdir.extractor import build_trace_memory_saved_callback
 
         if (
             self._is_subagent
@@ -689,6 +769,7 @@ class LoopGraphBuilder:
             capabilities=self._services.capabilities,
             cwd=runtime_cwd,
         )
+        from ...memory.memdir.fork_concurrency import default_fork_concurrency_limiter
         from ...memory.memdir.metrics import default_memory_fork_metrics
 
         metrics = default_memory_fork_metrics()
@@ -696,9 +777,100 @@ class LoopGraphBuilder:
             forked_runner=ForkedAgentRunner(
                 parent_runtime=parent_runtime,
                 metrics=metrics,
+                concurrency_limiter=default_fork_concurrency_limiter(),
             ),
             metrics=metrics,
+            on_memory_saved=build_trace_memory_saved_callback(trace_collector, session_id),
+        )
+
+    def _build_session_memory_extractor(
+        self,
+        *,
+        model: Any,
+        session_store: Any,
+        session_id: str,
+        session_memory_path: Any,
+        base_prompt: str,
+    ) -> Any | None:
+        """为 L3 Session Memory 组装 Fork 抽取器（对齐 memdir coordinator 构造）。"""
+        from pathlib import Path as StdPath
+
+        from ..subagent.context import ForkedParentRuntime
+        from ..subagent.forked_runner import ForkedAgentRunner
+        from ...memory.memdir.fork_concurrency import default_fork_concurrency_limiter
+        from ...memory.session.extractor import SessionMemoryExtractor
+
+        if self._services.loader is None or self._loop_loader is None:
+            return None
+
+        runtime_cwd = str(self._config.workspace.runtime_cwd or self._workspace_root)
+        parent_runtime = ForkedParentRuntime(
+            session_store=session_store,
+            tool_registry=self._loop_loader.registry,
+            tool_loader=self._services.loader,
+            model=model,
+            workspace_root=str(self._workspace_root),
+            agent_home_segment=self._workspace_cfg.agent_home_segment,
+            parent_run_id=session_id or None,
+            parent_conversation_session_id=session_id or None,
+            system_prompt=base_prompt,
+            capabilities=self._services.capabilities,
+            cwd=runtime_cwd,
+        )
+        forked_runner = ForkedAgentRunner(
+            parent_runtime=parent_runtime,
+            concurrency_limiter=default_fork_concurrency_limiter(),
+        )
+        return SessionMemoryExtractor(
+            forked_runner=forked_runner,
+            parent_runtime=parent_runtime,
+            session_memory_path=StdPath(session_memory_path),
+        )
+
+    def _build_memory_prefetch_coordinator(
+        self,
+        *,
+        model: Any,
+        session_store: Any,
+    ) -> Any | None:
+        from ...memory.memdir.gate import is_memory_prefetch_enabled
+        from ...memory.memdir.prefetch import MemoryPrefetchCoordinator
+        from ...memory.memdir.recall_service import MemoryRecallService
+
+        if self._is_subagent or not is_memory_enabled(self._workspace_cfg):
+            return None
+        if not is_memory_prefetch_enabled(self._workspace_cfg):
+            return None
+        recall_service = MemoryRecallService(
+            workspace_cfg=self._workspace_cfg,
+            model=model,
         )
+        return MemoryPrefetchCoordinator(
+            recall_service=recall_service,
+            workspace_cfg=self._workspace_cfg,
+            session_store=session_store,
+        )
+
+    def _consume_memory_prefetch_attachment_messages(self, state: dict[str, Any]) -> list[dict[str, Any]]:
+        coordinator = self._memory_prefetch_coordinator
+        if coordinator is None:
+            return []
+        iteration = int(state.get("turn_count", 0) or 0)
+        return coordinator.consume_attachment_messages(state, iteration=iteration)
+
+    def _patch_messages_with_memory_prefetch(
+        self,
+        state: dict[str, Any],
+        patch: dict[str, Any],
+    ) -> dict[str, Any]:
+        memory_attachments = self._consume_memory_prefetch_attachment_messages(state)
+        if not memory_attachments:
+            return patch
+        messages = list(patch.get("messages") or state.get("messages") or [])
+        messages.extend(memory_attachments)
+        patch = dict(patch)
+        patch["messages"] = messages
+        return patch
 
     def _resolve_workspace_config(self) -> None:
         raw_workspace_root = self._config.workspace.workspace_root
@@ -803,28 +975,6 @@ class LoopGraphBuilder:
                 structured_output_tools[structured_tool_info.tool.name] = structured_tool_info
         return initial_response_format, tool_strategy_for_setup, structured_output_tools
 
-    def _apply_explore_guidance(
-        self,
-        *,
-        append_system_prompt: str | None,
-        base_prompt: str | None,
-    ) -> tuple[str | None, SystemMessage | None]:
-        explore_guidance = build_explore_plan_guidance(self._available_tools)
-        if not explore_guidance:
-            return append_system_prompt, self._build_system_message(
-                base_prompt=base_prompt,
-                append_system_prompt=append_system_prompt,
-            )
-        updated_append_prompt = (
-            f"{append_system_prompt}\n\n{explore_guidance}"
-            if append_system_prompt
-            else explore_guidance
-        )
-        return updated_append_prompt, self._build_system_message(
-            base_prompt=base_prompt,
-            append_system_prompt=updated_append_prompt,
-        )
-
     def _build_tool_node(self) -> Any:
         self._prepare_compile_context()
         need_tool_node = bool(self._available_tools)
@@ -870,7 +1020,7 @@ class LoopGraphBuilder:
         model = self._model
         if self._config.enable_tool_call_degradation_fix and not isinstance(model, ToolCallDegradationCorrector):
             allowed_tool_names = _build_allowed_tool_names_for_degradation_correction(
-                tool_node=runtime_tools_node,
+                enabled_tool_names=set(self._enabled_tool_names),
                 built_in_tools=self._built_in_tools,
                 structured_output_tools=self._structured_output_tools,
             )
@@ -1066,7 +1216,10 @@ class LoopGraphBuilder:
         loop_entry_node = "hook_before_model"
         raw_loop_entry_node = "hook_before_model"
         provider_chain, has_skill_tool = self._build_provider_chain(tool_node)
-        if provider_chain:
+        wire_task_event_nodes = bool(provider_chain) or (
+            self._memory_prefetch_coordinator is not None and tool_node is not None
+        )
+        if wire_task_event_nodes:
             loop_entry_node = self._wire_task_event_nodes(
                 graph_inner=graph_inner,
                 provider_chain=provider_chain,
@@ -1092,6 +1245,7 @@ class LoopGraphBuilder:
             "loop_exit_node": "model",
             "exit_node": "hook_loop_end",
             "provider_chain": provider_chain,
+            "wire_task_event_nodes": wire_task_event_nodes,
         }
 
     def _build_provider_chain(self, tool_node: Any) -> tuple[list[QueuedCommandProvider], bool]:
@@ -1241,11 +1395,14 @@ class LoopGraphBuilder:
                                         "agent_id": event.scope.agent_id,
                                     }
                                 )
-                    return {
-                        "pending_task_batch_id": None,
-                        "pending_task_command_ids": [],
-                        "task_events": task_events,
-                    }
+                    return self._patch_messages_with_memory_prefetch(
+                        state,
+                        {
+                            "pending_task_batch_id": None,
+                            "pending_task_command_ids": [],
+                            "task_events": task_events,
+                        },
+                    )
                 messages = list(state.get("messages") or [])
                 # 冻结契约：task 通知附件仅经本节点注入；按 command_id 与已有 messages 去重
                 # （见 docs/design-docs/loop/agent-loop/post-tools-injection-contract.md）
@@ -1309,14 +1466,17 @@ class LoopGraphBuilder:
                                     "agent_id": event.scope.agent_id,
                                 }
                             )
-                return {
-                    "messages": messages,
-                    "pending_task_batch_id": encode_provider_batch_id(
-                        provider_index, batch.batch_id
-                    ),
-                    "pending_task_command_ids": list(batch.command_ids),
-                    "task_events": task_events,
-                }
+                return self._patch_messages_with_memory_prefetch(
+                    state,
+                    {
+                        "messages": messages,
+                        "pending_task_batch_id": encode_provider_batch_id(
+                            provider_index, batch.batch_id
+                        ),
+                        "pending_task_command_ids": list(batch.command_ids),
+                        "task_events": task_events,
+                    },
+                )
             except Exception:
                 if batch is not None and batch.batch_id:
                     if 0 <= provider_index < len(provider_chain):
@@ -1415,6 +1575,7 @@ class LoopGraphBuilder:
         loop_exit_node = routing["loop_exit_node"]
         exit_node = routing["exit_node"]
         provider_chain = routing["provider_chain"]
+        wire_task_event_nodes = routing["wire_task_event_nodes"]
         if tool_node is not None:
             self._wire_main_edges_with_tools(
                 graph_inner=graph_inner,
@@ -1423,6 +1584,7 @@ class LoopGraphBuilder:
                 loop_exit_node=loop_exit_node,
                 exit_node=exit_node,
                 provider_chain=provider_chain,
+                wire_task_event_nodes=wire_task_event_nodes,
             )
             return
         if len(self._structured_output_tools) > 0:
@@ -1446,8 +1608,9 @@ class LoopGraphBuilder:
         loop_exit_node: str,
         exit_node: str,
         provider_chain: list[QueuedCommandProvider],
+        wire_task_event_nodes: bool,
     ) -> None:
-        if provider_chain:
+        if wire_task_event_nodes:
             tools_model_destination = loop_entry_node
             tools_to_model_destinations = [loop_entry_node, exit_node]
         else:
@@ -1467,7 +1630,7 @@ class LoopGraphBuilder:
             ),
             tools_to_model_destinations,
         )
-        if not provider_chain:
+        if not wire_task_event_nodes:
             graph_inner.add_edge("prune_and_compress", loop_entry_node)
         graph_inner.add_edge(loop_exit_node, "hook_after_model")
         graph_inner.add_edge("hook_after_model", "hook_stop")
@@ -1494,7 +1657,7 @@ class LoopGraphBuilder:
         )
 
         loop_controller_destinations = ["tools", loop_entry_node, exit_node, "reactive_compact"]
-        if provider_chain and "task_event_commit_ack" not in loop_controller_destinations:
+        if wire_task_event_nodes and "task_event_commit_ack" not in loop_controller_destinations:
             loop_controller_destinations.append("task_event_commit_ack")
         graph_inner.add_conditional_edges(
             "loop_controller",