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

{langchain-agentx-python-1.0.8/langchain_agentx_python.egg-info → langchain-agentx-python-1.1.0}/PKG-INFO

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

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

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

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

@@ -92,7 +92,6 @@ from ...memory.instruction.runtime import (
 from ...memory.memdir.runtime import MemoryPromptBootstrap
 from ...memory.memdir.extractor import MemoryExtractionCoordinator
 from ...memory.memdir.paths import is_memory_enabled
-from ..hook.post_sample_hook import PostSampleHook
 # Session memory imports use lazy imports to avoid circular dependency
 # SessionMemoryCompactBridge uses lazy import to avoid circular dependency with memory.session.session_memory
 from ..prompt import SystemPromptSection, build_effective_system_prompt
@@ -405,31 +404,32 @@ class LoopGraphBuilder:
                 model_profile_registry=self._model_profile_registry,
             )
         # Lazy imports to avoid circular dependency with memory.session
+        session_summary_path: Path | None = None
         if self._config.enable_session_memory:
             from ...memory.session import SessionMemoryManager, make_session_memory_section
             from ...memory.session.compact_bridge import SessionMemoryCompactBridge
 
-            session_memory_path = self._workspace_cfg.session_memory_path(session_id)
+            session_summary_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,
+                    session_memory_path=session_summary_path,
                     base_prompt=base_prompt,
                 )
             self._session_memory_manager = SessionMemoryManager(
-                session_memory_path=session_memory_path,
+                session_memory_path=session_summary_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,
+                session_memory_path=session_summary_path,
                 extraction_state=self._session_memory_manager.extraction_state,
             )
-            self._dynamic_sections.append(make_session_memory_section(session_memory_path))
+            self._dynamic_sections.append(make_session_memory_section(session_summary_path))
         else:
             self._session_memory_manager = None
             self._session_memory_compact_bridge = None
@@ -468,6 +468,7 @@ class LoopGraphBuilder:
                     self._enabled_tool_names,
                     runtime_tools=runtime_tools,
                     include_session_memory_mechanics=self._config.enable_session_memory,
+                    session_summary_path=session_summary_path,
                     is_subagent=False,
                 )
             )
@@ -579,7 +580,6 @@ class LoopGraphBuilder:
             workspace_cfg=self._workspace_cfg,
             session_id=session_id or "",
             container_type=container_type,
-            post_sample_hook=PostSampleHook(memory_extractor=memory_extractor),
         )
         if self._config.trace.enabled:
             self._trace_callback_handler = TraceCallbackHandler(
@@ -746,7 +746,7 @@ class LoopGraphBuilder:
     ) -> MemoryExtractionCoordinator:
         from ..subagent.context import ForkedParentRuntime
         from ..subagent.forked_runner import ForkedAgentRunner
-        from ...memory.memdir.extractor import build_trace_memory_saved_callback
+        from ...memory.memdir.memory_saved import build_combined_memory_saved_callback
 
         if (
             self._is_subagent
@@ -780,7 +780,10 @@ class LoopGraphBuilder:
                 concurrency_limiter=default_fork_concurrency_limiter(),
             ),
             metrics=metrics,
-            on_memory_saved=build_trace_memory_saved_callback(trace_collector, session_id),
+            on_memory_saved=build_combined_memory_saved_callback(
+                trace_collector=trace_collector,
+                session_id=session_id,
+            ),
         )
 
     def _build_session_memory_extractor(
@@ -1787,6 +1790,8 @@ class LoopGraphBuilder:
         }
         if self._services.capabilities is not None:
             configurable_dict["capabilities"] = self._services.capabilities
+        if self._session_memory_manager is not None:
+            configurable_dict["session_memory_manager"] = self._session_memory_manager
         if "configurable" in config:
             # Merge existing configurable keys (e.g., tool_loader, session_store)
             configurable_dict = {**config["configurable"], **configurable_dict}

{langchain-agentx-python-1.0.8 → langchain-agentx-python-1.1.0}/langchain_agentx/loop/hook/graph_wiring.py

@@ -8,7 +8,7 @@ graph_wiring.py — Hook 与 Loop 图装配协作者。
     由 loop/graph/factory.py 在构图阶段调用，产出 loop_start / stop_hooks 节点。
 
 当前裁剪范围：
-    Phase 4：after_model 注入 PostSampleHook；stop_hooks 兜底触发 + drain。
+    L2 memdir 抽取仅 stop_hooks_node；L3 session memory 在 after_model 触发。
 """
 
 from __future__ import annotations
@@ -20,7 +20,6 @@ from uuid import uuid4
 from .async_hook_runner import AsyncHookRunner
 from .engine import HookEngine
 from .hook_projection import derive_hook_outcome, hook_result_to_event_dict
-from .post_sample_hook import PostSampleHook
 from .types import AggregatedHookResult, HookContext, HookEvent
 
 
@@ -46,7 +45,6 @@ class HookGraphWiring:
     session_id: str | None = None
     container_type: str = "interactive"
     hook_runner: AsyncHookRunner = field(default_factory=AsyncHookRunner)
-    post_sample_hook: PostSampleHook | None = None
 
     def loop_start_node(self, state: dict[str, Any], runtime: Any) -> dict[str, Any]:
         run_id = state.get("_run_id")
@@ -90,13 +88,6 @@ class HookGraphWiring:
                 patch.update(dict(result.state_patch))
         if self.session_memory is not None:
             self.session_memory.maybe_trigger(state)
-        if self.post_sample_hook is not None:
-            self.post_sample_hook.fire_and_forget(
-                state=state,
-                workspace_cfg=self.workspace_cfg,
-                session_id=self.session_id or str(state.get("_session_id") or ""),
-                container_type=self.container_type,
-            )
         if self.trace_lifecycle_collector is not None:
             patch.update(self.trace_lifecycle_collector.after_model_node(state))
         return patch
@@ -110,6 +101,7 @@ class HookGraphWiring:
         )
         if not has_terminal_resolution:
             return {}
+        patch: dict[str, Any] = {}
         if self.memory_extractor is not None and self.workspace_cfg is not None:
             self.memory_extractor.trigger_from_state(
                 state=state,
@@ -121,13 +113,21 @@ class HookGraphWiring:
             drain = getattr(self.memory_extractor, "drain_on_stop", None)
             if callable(drain):
                 drain()
+            drain_saved = getattr(self.memory_extractor, "drain_memory_saved_ui_events", None)
+            if callable(drain_saved):
+                saved_ui = drain_saved()
+                if saved_ui:
+                    patch["_hook_ui_events"] = saved_ui
         result = self._execute_sync(HookEvent.STOP, state)
-        if result is None:
-            return {}
-        patch = {"__hook_result__": _to_hook_result_dict(result)}
-        patch.update(self._drain_hook_ui_events())
-        if result.state_patch:
-            patch.update(dict(result.state_patch))
+        if result is not None:
+            patch["__hook_result__"] = _to_hook_result_dict(result)
+            hook_ui_patch = self._drain_hook_ui_events()
+            if hook_ui_patch:
+                patch.setdefault("_hook_ui_events", []).extend(
+                    hook_ui_patch.get("_hook_ui_events") or []
+                )
+            if result.state_patch:
+                patch.update(dict(result.state_patch))
         return patch
 
     def loop_end_node(self, state: dict[str, Any], runtime: Any) -> dict[str, Any]:

{langchain-agentx-python-1.0.8 → langchain-agentx-python-1.1.0}/langchain_agentx/loop/model/model_node.py

@@ -389,15 +389,17 @@ class ModelNode(Runnable):
         system_message = self._system_message
         if self._has_volatile_sections:
             from ..prompt.builder import build_effective_system_prompt
+            from ...memory.memdir.entrypoint_context import prompt_section_messages_scope
 
             section_cache = state.get("section_cache") or {}
-            effective = build_effective_system_prompt(
-                system_prompt=self._base_prompt,
-                override_system_prompt=self._override_prompt,
-                append_system_prompt=self._append_prompt,
-                dynamic_sections=self._dynamic_sections,
-                section_cache=section_cache,
-            )
+            with prompt_section_messages_scope(state.get("messages") or []):
+                effective = build_effective_system_prompt(
+                    system_prompt=self._base_prompt,
+                    override_system_prompt=self._override_prompt,
+                    append_system_prompt=self._append_prompt,
+                    dynamic_sections=self._dynamic_sections,
+                    section_cache=section_cache,
+                )
             system_message = (
                 SystemMessage(content=effective) if effective is not None else None
             )

{langchain-agentx-python-1.0.8 → langchain-agentx-python-1.1.0}/langchain_agentx/loop/model/model_nodes.py

@@ -256,14 +256,17 @@ class _ModelNodeBuilder:
         if self._has_volatile_sections:
             from ..prompt.builder import build_effective_system_prompt
             from langchain_core.messages import SystemMessage as _SystemMessage
+            from ...memory.memdir.entrypoint_context import prompt_section_messages_scope
+
             section_cache: dict[str, Any] = state.get("section_cache") or {}
-            effective = build_effective_system_prompt(
-                system_prompt=self._base_prompt,
-                override_system_prompt=self._override_prompt,
-                append_system_prompt=self._append_prompt,
-                dynamic_sections=self._dynamic_sections,
-                section_cache=section_cache,
-            )
+            with prompt_section_messages_scope(state.get("messages") or []):
+                effective = build_effective_system_prompt(
+                    system_prompt=self._base_prompt,
+                    override_system_prompt=self._override_prompt,
+                    append_system_prompt=self._append_prompt,
+                    dynamic_sections=self._dynamic_sections,
+                    section_cache=section_cache,
+                )
             system_message = _SystemMessage(content=effective) if effective is not None else None
 
         # force_text_exit: max_steps 达限时，清空工具列表强制模型输出文本

{langchain-agentx-python-1.0.8 → langchain-agentx-python-1.1.0}/langchain_agentx/loop/prompt/tool_aware_sections.py

@@ -17,6 +17,7 @@ loop/prompt/tool_aware_sections.py — 工具感知 Prompt 段与纠偏白名单
 
 from __future__ import annotations
 
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Iterable, Sequence
 
 from langchain_agentx.tools.agent.prompt import (
@@ -58,6 +59,7 @@ def build_tool_aware_prompt_sections(
     *,
     runtime_tools: Sequence[Any],
     include_session_memory_mechanics: bool = True,
+    session_summary_path: Path | None = None,
     is_subagent: bool = False,
 ) -> list[SystemPromptSection]:
     """主 Loop 工具感知 ⑥ 段；子图 is_subagent=True 时不注入。"""
@@ -67,11 +69,18 @@ def build_tool_aware_prompt_sections(
         return []
 
     sections: list[SystemPromptSection] = []
-    if include_session_memory_mechanics and EDIT_TOOL_NAME in enabled:
+    if (
+        include_session_memory_mechanics
+        and EDIT_TOOL_NAME in enabled
+        and session_summary_path is not None
+    ):
         from langchain_agentx.memory.session.prompts import build_session_memory_mechanics_prompt
 
         sections.append(
-            section("session_memory_mechanics", build_session_memory_mechanics_prompt)
+            section(
+                "session_memory_mechanics",
+                lambda: build_session_memory_mechanics_prompt(notes_path=session_summary_path),
+            )
         )
     from langchain_agentx.loop.prompt.using_your_tools import (
         build_using_your_tools_section,

{langchain-agentx-python-1.0.8 → langchain-agentx-python-1.1.0}/langchain_agentx/loop/subagent/transcript.py

@@ -6,6 +6,8 @@ CC 对照：src/agent/subagent/transcript.ts TranscriptStore 接口
 当前裁剪范围：v1 Protocol + 内存实现 + JSONL 文件后端
 """
 
+from __future__ import annotations
+
 import json
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -106,12 +108,17 @@ class InMemoryTranscriptStore:
 
 
 class JsonlTranscriptStore:
-    """JSONL 文件实现（按 session/agent 隔离 transcript）。"""
+    """JSONL 文件实现（CC project_dir 布局 · M6）。"""
 
-    def __init__(self, transcripts_dir: str | Path, session_id: str) -> None:
-        self._transcripts_dir = Path(transcripts_dir)
+    def __init__(self, project_dir: str | Path, session_id: str) -> None:
+        self._project_dir = Path(project_dir)
         self._session_id = session_id
 
+    @classmethod
+    def from_layout(cls, layout: object, session_id: str) -> JsonlTranscriptStore:
+        """从 ProjectMemoryLayout 构造 store。"""
+        return cls(layout.project_dir, session_id)
+
     def write_transcript(
         self,
         agent_id: str,
@@ -163,11 +170,22 @@ class JsonlTranscriptStore:
         if path.exists():
             path.unlink()
         session_dir = path.parent
-        if session_dir.exists() and not any(session_dir.iterdir()):
-            session_dir.rmdir()
+        if session_dir.exists() and session_dir.name == "subagents":
+            if not any(session_dir.iterdir()):
+                session_dir.rmdir()
+            grand = session_dir.parent
+            if grand.exists() and grand.name == self._session_id:
+                try:
+                    if not any(grand.iterdir()):
+                        grand.rmdir()
+                except OSError:
+                    pass
 
     def _resolve_path(self, agent_id: str) -> Path:
-        return self._transcripts_dir / self._session_id / f"{agent_id}.jsonl"
+        if agent_id == self._session_id:
+            return self._project_dir / f"{self._session_id}.jsonl"
+        safe_agent = agent_id.replace("/", "-").replace("\\", "-").strip() or "agent"
+        return self._project_dir / self._session_id / "subagents" / f"{safe_agent}.jsonl"
 
     def _encode_line(self, payload: dict[str, Any]) -> str:
         return json.dumps(payload, ensure_ascii=False) + "\n"

{langchain-agentx-python-1.0.8 → langchain-agentx-python-1.1.0}/langchain_agentx/memory/memdir/cursor_store.py

@@ -8,7 +8,7 @@ cursor_store.py — Layer 2 记忆抽取 cursor 持久化。
     MemoryExtractionCoordinator → MemoryExtractionCursorStore。
 
 当前裁剪范围：
-    路径 {memory_dir}/.cursor/{session_id}；兼容旧 conversation sessions_dir/*.cursor。
+    路径 {l2_memory_dir}/.cursor/{session_id}（CC projects 树）。
 """
 
 from __future__ import annotations
@@ -51,11 +51,6 @@ class MemoryExtractionCursorStore:
     def cursor_path(self, workspace_cfg: ResolvedAgentStateConfig, session_id: str) -> Path:
         return workspace_cfg.memory_dir / ".cursor" / session_id
 
-    def legacy_cursor_path(
-        self, workspace_cfg: ResolvedAgentStateConfig, session_id: str
-    ) -> Path:
-        return workspace_cfg.sessions_dir / f"{session_id}.cursor"
-
     def session_key(self, container_type: str, session_id: str) -> str:
         return f"{container_type}:{session_id}"
 
@@ -72,11 +67,6 @@ class MemoryExtractionCursorStore:
 
         path = self.cursor_path(workspace_cfg, session_id)
         state = self._read_json(path)
-        if state is None:
-            legacy = self.legacy_cursor_path(workspace_cfg, session_id)
-            legacy_uuid = self._read_legacy_uuid(legacy)
-            if legacy_uuid:
-                state = MemoryExtractionCursorState(last_memory_message_uuid=legacy_uuid)
         if state is None:
             state = MemoryExtractionCursorState()
         self._cache[key] = state
@@ -101,20 +91,13 @@ class MemoryExtractionCursorStore:
             return None
         try:
             data = json.loads(path.read_text(encoding="utf-8"))
-        except (OSError, json.JSONDecodeError, TypeError, ValueError) as exc:
+        except (OSError, json.JSONDecodeError) as exc:
             logger.warning("ignore corrupt memory cursor file %s: %s", path, exc)
             return None
         if not isinstance(data, dict):
             return None
         return MemoryExtractionCursorState.from_dict(data)
 
-    @staticmethod
-    def _read_legacy_uuid(path: Path) -> str | None:
-        if not path.exists():
-            return None
-        value = path.read_text(encoding="utf-8").strip()
-        return value or None
-
     @staticmethod
     def _write_json_atomic(path: Path, state: MemoryExtractionCursorState) -> None:
         path.parent.mkdir(parents=True, exist_ok=True)

langchain-agentx-python-1.1.0/langchain_agentx/memory/memdir/entrypoint_context.py

@@ -0,0 +1,103 @@
+"""
+memory/memdir/entrypoint_context.py — MEMORY.md 正文 volatile 注入与 prefetch 去重。
+
+职责：
+    将 MEMORY.md 索引正文从 auto_memory mechanics 拆出，经独立 system section 注入；
+    prefetch 已 surface 相关记忆时跳过索引（对齐 CC filterInjectedMemoryFiles / tengu_moth_copse）。
+
+链路位置：
+    MemoryPromptBootstrap → volatile_section("memory_entrypoint")；
+    ModelNode 在 resolve volatile sections 前设置 prompt_section_messages 上下文。
+
+当前裁剪范围：
+    仅 L2 REPL auto memory entrypoint；Agent build_memory_prompt 不在此模块。
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from contextvars import ContextVar, Token
+from typing import Any, Iterator
+
+from langchain_agentx.loop.prompt.sections import SystemPromptSection, volatile_section
+from langchain_agentx.workspace import ResolvedAgentStateConfig
+
+from .gate import is_memory_prefetch_enabled
+from .loader import MemoryPromptLoader
+from .paths import is_memory_enabled
+from .prefetch import collect_surfaced_from_messages
+from .types import MEMORY_ENTRYPOINT_NAME
+
+_prompt_section_messages: ContextVar[list[Any] | None] = ContextVar(
+    "prompt_section_messages",
+    default=None,
+)
+
+
+def get_prompt_section_messages() -> list[Any]:
+    raw = _prompt_section_messages.get()
+    return list(raw) if raw else []
+
+
+@contextmanager
+def prompt_section_messages_scope(messages: list[Any]) -> Iterator[None]:
+    token: Token = _prompt_section_messages.set(list(messages))
+    try:
+        yield
+    finally:
+        _prompt_section_messages.reset(token)
+
+
+def should_filter_injected_memory_entrypoint(
+    messages: list[Any],
+    workspace_cfg: ResolvedAgentStateConfig,
+) -> bool:
+    """prefetch 已注入 relevant_memories 时跳过 MEMORY.md 索引（对齐 CC filterInjectedMemoryFiles）。"""
+    if not is_memory_prefetch_enabled(workspace_cfg):
+        return False
+    surfaced = collect_surfaced_from_messages(messages)
+    return bool(surfaced.paths)
+
+
+def format_memory_entrypoint_user_context(
+    *,
+    body: str,
+    warning: str | None = None,
+    entrypoint_name: str = MEMORY_ENTRYPOINT_NAME,
+) -> str:
+    lines = [f"# {entrypoint_name}", "", body.strip()]
+    if warning:
+        lines.extend(["", warning.strip()])
+    return "\n".join(lines)
+
+
+def make_memory_entrypoint_section(
+    loader: MemoryPromptLoader,
+    workspace_cfg: ResolvedAgentStateConfig,
+) -> SystemPromptSection:
+    def _compute() -> str | None:
+        if not is_memory_enabled(workspace_cfg):
+            return None
+        messages = get_prompt_section_messages()
+        if should_filter_injected_memory_entrypoint(messages, workspace_cfg):
+            return None
+        loaded = loader.load_memory_entrypoint_content()
+        if loaded is None:
+            return None
+        body, warning = loaded
+        return format_memory_entrypoint_user_context(body=body, warning=warning)
+
+    return volatile_section(
+        name="memory_entrypoint",
+        compute=_compute,
+        reason="MEMORY.md index may be skipped when prefetch surfaced relevant memories",
+    )
+
+
+__all__ = [
+    "format_memory_entrypoint_user_context",
+    "get_prompt_section_messages",
+    "make_memory_entrypoint_section",
+    "prompt_section_messages_scope",
+    "should_filter_injected_memory_entrypoint",
+]