langchain-agentx-python 1.1.1__tar.gz → 1.1.2__tar.gz

{langchain-agentx-python-1.1.1/langchain_agentx_python.egg-info → langchain-agentx-python-1.1.2}/PKG-INFO

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

{langchain-agentx-python-1.1.1 → langchain-agentx-python-1.1.2}/langchain_agentx/__init__.py

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

{langchain-agentx-python-1.1.1 → langchain-agentx-python-1.1.2}/langchain_agentx/loop/graph/factory.py

@@ -43,7 +43,6 @@ from langgraph.graph.state import StateGraph
 import asyncio
 import dataclasses
 import logging
-import threading
 import uuid
 from types import MethodType
 
@@ -936,29 +935,6 @@ class LoopGraphBuilder:
             write_roots=list(self._config.workspace.write_roots) or None,
         )
 
-    @staticmethod
-    def _run_coro_sync(coro: Any) -> Any:
-        try:
-            asyncio.get_running_loop()
-        except RuntimeError:
-            return asyncio.run(coro)
-
-        result: dict[str, Any] = {}
-        error: dict[str, Exception] = {}
-
-        def _runner() -> None:
-            try:
-                result["value"] = asyncio.run(coro)
-            except Exception as exc:  # pragma: no cover
-                error["value"] = exc
-
-        thread = threading.Thread(target=_runner, daemon=True)
-        thread.start()
-        thread.join()
-        if "value" in error:
-            raise error["value"]
-        return result.get("value")
-
     def _build_system_message(
         self,
         *,
@@ -1187,17 +1163,60 @@ class LoopGraphBuilder:
         if tool_node is not None:
             graph_inner.add_node("tools", tool_node)
 
-            def _prune_and_compress_node(state, runtime):
-                return self._run_prune_and_compress_with_trace(state)
-
             graph_inner.add_node(
                 "prune_and_compress",
-                RunnableCallable(_prune_and_compress_node, None, trace=False),
+                RunnableCallable(
+                    self._prune_and_compress_node,
+                    self._prune_and_compress_node_async,
+                    trace=False,
+                ),
             )
         return graph_inner
 
+    def _prune_and_compress_node(self, state: dict[str, Any], runtime: Any) -> dict[str, Any]:
+        return self._run_prune_and_compress_with_trace(state)
+
+    async def _prune_and_compress_node_async(
+        self, state: dict[str, Any], runtime: Any
+    ) -> dict[str, Any]:
+        return await self._run_prune_and_compress_with_trace_async(state)
+
+    def _sync_wait_for_session_memory_extraction(self) -> None:
+        """sync invoke 路径：无 running loop 时用 asyncio.run；否则跳过 wait（需 ainvoke）。"""
+        if self._session_memory_compact_bridge is None:
+            return
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            asyncio.run(self._session_memory_compact_bridge.wait_for_extraction())
+            return
+        logger.warning(
+            "prune_and_compress: sync invoke while event loop is running; "
+            "skipping wait_for_extraction (use ainvoke for CC-aligned wait)"
+        )
+
+    def _apply_prune_and_compress(self, state: dict[str, Any]) -> dict[str, Any]:
+        if self._session_memory_compact_bridge is not None:
+            compacted_messages = self._session_memory_compact_bridge.try_compact(
+                list(state.get("messages") or [])
+            )
+            if compacted_messages is not None:
+                return {
+                    "messages": compacted_messages,
+                    "collapse_retry_available": True,
+                    "compaction_pipeline_meta": {
+                        "autocompact_mode": "session_memory",
+                        "session_memory_compaction": "applied",
+                    },
+                }
+        patch = self._loop_context_compaction.run(state, model=self._model)
+        compaction_meta = patch.get("compaction_pipeline_meta")
+        if isinstance(compaction_meta, dict):
+            patch["collapse_retry_available"] = bool(compaction_meta.get("tokens_freed_sum", 0))
+        return patch
+
     def _run_prune_and_compress_with_trace(self, state: dict[str, Any]) -> dict[str, Any]:
-        """执行 compaction，并在当前 session 内记录 compaction span。"""
+        """执行 compaction，并在当前 session 内记录 compaction span（sync 路径）。"""
         collector = state.get("_trace_collector")
         run_id = state.get("_run_id")
         span_id: str | None = None
@@ -1215,24 +1234,53 @@ class LoopGraphBuilder:
                 metadata={"visibility": "summary_only"},
             )
         try:
-            if self._session_memory_compact_bridge is not None:
-                self._run_coro_sync(self._session_memory_compact_bridge.wait_for_extraction())
-                compacted_messages = self._session_memory_compact_bridge.try_compact(
-                    list(state.get("messages") or [])
+            self._sync_wait_for_session_memory_extraction()
+            patch = self._apply_prune_and_compress(state)
+        except Exception as exc:
+            if span_id is not None:
+                collector.span_end(
+                    span_id=span_id,
+                    session_id=run_id,
+                    error=str(exc),
+                    metadata={"visibility": "summary_only"},
                 )
-                if compacted_messages is not None:
-                    return {
-                        "messages": compacted_messages,
-                        "collapse_retry_available": True,
-                        "compaction_pipeline_meta": {
-                            "autocompact_mode": "session_memory",
-                            "session_memory_compaction": "applied",
-                        },
-                    }
-            patch = self._loop_context_compaction.run(state, model=self._model)
+            raise
+        if span_id is not None:
+            metadata: dict[str, Any] = {"visibility": "summary_only"}
             compaction_meta = patch.get("compaction_pipeline_meta")
             if isinstance(compaction_meta, dict):
-                patch["collapse_retry_available"] = bool(compaction_meta.get("tokens_freed_sum", 0))
+                metadata["compaction_pipeline_meta"] = compaction_meta
+            collector.span_end(
+                span_id=span_id,
+                session_id=run_id,
+                metadata=metadata,
+            )
+        return patch
+
+    async def _run_prune_and_compress_with_trace_async(
+        self, state: dict[str, Any]
+    ) -> dict[str, Any]:
+        """async compaction（CC 对齐）：在 owner loop 上 await wait_for_extraction。"""
+        collector = state.get("_trace_collector")
+        run_id = state.get("_run_id")
+        span_id: str | None = None
+        if (
+            collector is not None
+            and isinstance(run_id, str)
+            and run_id
+            and hasattr(collector, "has_session")
+            and collector.has_session(run_id)
+        ):
+            span_id = collector.span_start(
+                span_type="compaction",
+                name="prune_and_compress",
+                session_id=run_id,
+                metadata={"visibility": "summary_only"},
+            )
+        try:
+            if self._session_memory_compact_bridge is not None:
+                await self._session_memory_compact_bridge.wait_for_extraction()
+            patch = self._apply_prune_and_compress(state)
         except Exception as exc:
             if span_id is not None:
                 collector.span_end(
@@ -1575,7 +1623,11 @@ class LoopGraphBuilder:
         )
         graph_inner.add_node(
             "hook_loop_end",
-            RunnableCallable(self._hook_graph_wiring.loop_end_node, None, trace=False),
+            RunnableCallable(
+                self._hook_graph_wiring.loop_end_node,
+                self._hook_graph_wiring.loop_end_node_async,
+                trace=False,
+            ),
         )
         graph_inner.add_edge("hook_loop_end", END)
 

{langchain-agentx-python-1.1.1 → langchain-agentx-python-1.1.2}/langchain_agentx/loop/hook/graph_wiring.py

@@ -101,7 +101,6 @@ 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,
@@ -110,14 +109,7 @@ class HookGraphWiring:
                 container_type=self.container_type,
                 force=True,
             )
-            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
+        patch: dict[str, Any] = {}
         result = self._execute_sync(HookEvent.STOP, state)
         if result is not None:
             patch["__hook_result__"] = _to_hook_result_dict(result)
@@ -130,6 +122,36 @@ class HookGraphWiring:
                 patch.update(dict(result.state_patch))
         return patch
 
+    async def loop_end_node_async(self, state: dict[str, Any], runtime: Any) -> dict[str, Any]:
+        """async loop_end：在事件循环上 await drain，避免 sync stop 节点 blocking 死锁。"""
+        memory_patch = await self._drain_memory_extraction_async()
+        base_patch = self.loop_end_node(state, runtime)
+        if not memory_patch:
+            return base_patch
+        if not base_patch:
+            return memory_patch
+        merged = dict(base_patch)
+        if "_hook_ui_events" in memory_patch:
+            merged.setdefault("_hook_ui_events", []).extend(
+                memory_patch.get("_hook_ui_events") or []
+            )
+        return merged
+
+    async def _drain_memory_extraction_async(self) -> dict[str, Any]:
+        if self.memory_extractor is None:
+            return {}
+        drain = getattr(self.memory_extractor, "drain_pending_extraction", None)
+        if callable(drain):
+            from langchain_agentx.memory.memdir.extractor import STOP_HOOK_DRAIN_TIMEOUT_MS
+
+            await drain(STOP_HOOK_DRAIN_TIMEOUT_MS)
+        drain_saved = getattr(self.memory_extractor, "drain_memory_saved_ui_events", None)
+        if callable(drain_saved):
+            saved_ui = drain_saved()
+            if saved_ui:
+                return {"_hook_ui_events": saved_ui}
+        return {}
+
     def loop_end_node(self, state: dict[str, Any], runtime: Any) -> dict[str, Any]:
         if self.memory_prefetch_coordinator is not None:
             self.memory_prefetch_coordinator.abort_turn()

{langchain-agentx-python-1.1.1 → langchain-agentx-python-1.1.2}/langchain_agentx/loop/prompt/static_system_prompt.py

@@ -17,15 +17,29 @@ from __future__ import annotations
 
 def build_default_static_system_prompt() -> str:
     """返回 CC 3 月 static 段拼接（langchain_agentx 品牌）。"""
-    sections = [
-        _intro_section(),
-        _system_section(),
-        _doing_tasks_section(),
-        _actions_section(),
-        _tone_section(),
-        _output_efficiency_section(),
-    ]
-    return "\n\n".join(sections)
+    return "\n\n".join(
+        [
+            build_cli_c5_prefix(),
+            build_cli_c5_suffix(),
+        ]
+    )
+
+
+def build_cli_c5_prefix() -> str:
+    """CLI-C5 PREFIX：intro 至 Executing actions（dynamic 段之前）。"""
+    return "\n\n".join(
+        [
+            _intro_section(),
+            _system_section(),
+            _doing_tasks_section(),
+            _actions_section(),
+        ]
+    )
+
+
+def build_cli_c5_suffix() -> str:
+    """CLI-C5 SUFFIX：Tone + Output efficiency（append 在 dynamic 段之后）。"""
+    return "\n\n".join([_tone_section(), _output_efficiency_section()])
 
 
 def _intro_section() -> str:

{langchain-agentx-python-1.1.1 → langchain-agentx-python-1.1.2}/langchain_agentx/memory/memdir/extractor.py

@@ -167,7 +167,10 @@ class MemoryExtractionCoordinator:
         task.add_done_callback(self._tasks.discard)
 
     def drain_on_stop(self, timeout_ms: int = STOP_HOOK_DRAIN_TIMEOUT_MS) -> None:
-        """stop hook 阻塞等待 in-flight 抽取（跨线程 schedule 到任务所属 loop）；超时 abort。"""
+        """跨线程阻塞等待 in-flight 抽取（勿在 owner 事件循环线程调用，会死锁）。
+
+        主 Loop graph 路径应使用 ``loop_end_node_async`` → ``await drain_pending_extraction``。
+        """
         if not self._tasks:
             return
         try:
@@ -176,6 +179,16 @@ class MemoryExtractionCoordinator:
             return
         if loop.is_closed():
             return
+        try:
+            running = asyncio.get_running_loop()
+        except RuntimeError:
+            running = None
+        if running is loop:
+            logger.warning(
+                "drain_on_stop skipped: called from owner event loop thread; "
+                "use await drain_pending_extraction() instead"
+            )
+            return
         deadline_s = timeout_ms / 1000.0 + 2.0
         future = asyncio.run_coroutine_threadsafe(
             self.drain_pending_extraction(timeout_ms=timeout_ms),

{langchain-agentx-python-1.1.1 → langchain-agentx-python-1.1.2}/langchain_agentx/observability/trace/trace_callback.py

@@ -35,6 +35,14 @@ class TraceCallbackHandler(BaseCallbackHandler):
     _llm_started_at: dict[str, float] = field(default_factory=dict)
     _tool_started_at: dict[str, float] = field(default_factory=dict)
 
+    def __hash__(self) -> int:
+        # LangGraph / LangChain 合并 RunnableConfig.callbacks 时使用 set()；
+        # 按实例 identity 哈希，避免 fork 子链携带 handler 时 TypeError。
+        return id(self)
+
+    def __eq__(self, other: object) -> bool:
+        return self is other
+
     def _ensure_session(self) -> None:
         if self.collector.has_session(self.session_id):
             return

{langchain-agentx-python-1.1.1 → langchain-agentx-python-1.1.2/langchain_agentx_python.egg-info}/PKG-INFO

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

{langchain-agentx-python-1.1.1 → langchain-agentx-python-1.1.2}/pyproject.toml

@@ -4,7 +4,7 @@
 
  [project]
  name = "langchain-agentx-python"
- version = "1.1.1"
+ version = "1.1.2"
  description = "LangChain/LangGraph-based agent utilities for CodeBaseX."
  readme = "README.md"
  requires-python = ">=3.11"