langchain-agentx-python 1.2.6__tar.gz → 1.2.8__tar.gz

{langchain-agentx-python-1.2.6 → langchain-agentx-python-1.2.8}/PKG-INFO

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

{langchain-agentx-python-1.2.6 → langchain-agentx-python-1.2.8}/langchain_agentx/__init__.py

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

{langchain-agentx-python-1.2.6 → langchain-agentx-python-1.2.8}/langchain_agentx/loop/graph/graph_edges.py

@@ -32,7 +32,7 @@ from langchain_core.messages import AIMessage, AnyMessage, HumanMessage, ToolMes
 from langgraph._internal._runnable import RunnableCallable
 from langgraph.graph.state import StateGraph
 from langgraph.prebuilt.tool_node import ToolNode
-from ..hook.async_hook_runner import AsyncHookRunner
+from ..hook.async_hook_runner import AsyncHookRunner, get_process_async_hook_runner
 from ..hook.hook_projection import hook_result_to_event_dict
 from ..hook.types import HookContext, HookEvent
 
@@ -96,7 +96,7 @@ def _execute_hook_common(
         return None
     hook_runner = state.get("_hook_runner")
     if not isinstance(hook_runner, AsyncHookRunner):
-        hook_runner = AsyncHookRunner()
+        hook_runner = get_process_async_hook_runner()
     ctx_kwargs: dict[str, Any] = {
         "event": event,
         "state": state,

{langchain-agentx-python-1.2.6 → langchain-agentx-python-1.2.8}/langchain_agentx/loop/hook/__init__.py

@@ -12,7 +12,11 @@ loop.hook — Hook 子系统（P1/P2）。
     Phase 1：新增 HookProgressPayloadBuilder 用于 progress 展示元数据构建。
 """
 
-from .async_hook_runner import AsyncHookRunner
+from .async_hook_runner import (
+    AsyncHookRunner,
+    get_process_async_hook_runner,
+    shutdown_process_async_hook_runner,
+)
 from .config import HookCandidate, HookCandidateDecision, HookSpec, HooksConfigSnapshot
 from .engine import HookEngine
 from .executors import AgentExecutor, CommandExecutor, HttpExecutor, PromptExecutor
@@ -40,6 +44,8 @@ from .types import (
 __all__ = [
     "AggregatedHookResult",
     "AsyncHookRunner",
+    "get_process_async_hook_runner",
+    "shutdown_process_async_hook_runner",
     "ATTACHMENT_HOOK_BLOCKING_ERROR",
     "ATTACHMENT_HOOK_CANCELLED",
     "ATTACHMENT_HOOK_NON_BLOCKING_ERROR",

{langchain-agentx-python-1.2.6 → langchain-agentx-python-1.2.8}/langchain_agentx/loop/hook/async_hook_runner.py

@@ -8,12 +8,14 @@ async_hook_runner.py — Hook 同步入口的异步执行协作者。
     HookGraphWiring 与 graph_edges 通过本协作者调用 HookEngine.execute()。
 
 当前裁剪范围：
-    P1 仅实现线程桥接执行；不引入 nest_asyncio，不修改外部事件循环。
+    P1 仅实现线程桥接执行；不引入 nest_asyncio，不修改外部 event loop。
+    进程级单例 ThreadPoolExecutor，atexit 显式 shutdown，禁止 fallback 裸 new。
 """
 
 from __future__ import annotations
 
 import asyncio
+import atexit
 from concurrent.futures import ThreadPoolExecutor
 from threading import Lock
 
@@ -45,7 +47,10 @@ class AsyncHookRunner:
     def _get_or_create_executor(self) -> ThreadPoolExecutor:
         with self._executor_lock:
             if self._executor is None:
-                self._executor = ThreadPoolExecutor(max_workers=1)
+                self._executor = ThreadPoolExecutor(
+                    max_workers=1,
+                    thread_name_prefix="async-hook-runner",
+                )
             return self._executor
 
     def close(self) -> None:
@@ -59,4 +64,33 @@ class AsyncHookRunner:
         return asyncio.run(hook_engine.execute(ctx))
 
 
-__all__ = ["AsyncHookRunner"]
+_process_runner: AsyncHookRunner | None = None
+_process_runner_lock = Lock()
+
+
+def get_process_async_hook_runner() -> AsyncHookRunner:
+    """进程级 Hook 桥接 runner（单例，避免 graph_edges fallback 泄漏线程池）。"""
+    global _process_runner
+    with _process_runner_lock:
+        if _process_runner is None:
+            _process_runner = AsyncHookRunner()
+        return _process_runner
+
+
+def shutdown_process_async_hook_runner() -> None:
+    """关闭进程级 runner 线程池（测试 / 进程退出）。"""
+    global _process_runner
+    with _process_runner_lock:
+        if _process_runner is not None:
+            _process_runner.close()
+            _process_runner = None
+
+
+atexit.register(shutdown_process_async_hook_runner)
+
+
+__all__ = [
+    "AsyncHookRunner",
+    "get_process_async_hook_runner",
+    "shutdown_process_async_hook_runner",
+]

{langchain-agentx-python-1.2.6 → langchain-agentx-python-1.2.8}/langchain_agentx/loop/hook/graph_wiring.py

@@ -17,7 +17,7 @@ from dataclasses import dataclass, field
 from typing import Any
 from uuid import uuid4
 
-from .async_hook_runner import AsyncHookRunner
+from .async_hook_runner import AsyncHookRunner, get_process_async_hook_runner
 from .engine import HookEngine
 from .hook_projection import derive_hook_outcome, hook_result_to_event_dict
 from .types import AggregatedHookResult, HookContext, HookEvent
@@ -44,7 +44,7 @@ class HookGraphWiring:
     workspace_cfg: Any | None = None
     session_id: str | None = None
     container_type: str = "interactive"
-    hook_runner: AsyncHookRunner = field(default_factory=AsyncHookRunner)
+    hook_runner: AsyncHookRunner = field(default_factory=get_process_async_hook_runner)
 
     def loop_start_node(self, state: dict[str, Any], runtime: Any) -> dict[str, Any]:
         run_id = state.get("_run_id")

{langchain-agentx-python-1.2.6 → langchain-agentx-python-1.2.8}/langchain_agentx/loop/stream/loop_driver.py

@@ -13,8 +13,9 @@ loop_driver.py — Loop-aware shared stream driver.
 
 from __future__ import annotations
 
+import asyncio
 import logging
-from typing import Any, AsyncIterator
+from typing import Any, AsyncIterator, Literal
 
 from langgraph.errors import GraphRecursionError
 
@@ -23,6 +24,8 @@ from ..exit.reason_codes import (
     TERMINAL_REASON_RUNTIME_BUDGET_EXHAUSTED,
 )
 from ..exit.terminal import apply_terminal_reason_projection, build_loop_terminal
+from langchain_agentx.observability.events.tool_call_id_resolver import ToolCallIdResolver
+
 from .result import StreamDriverResult
 from .synthetic_events import (
     build_synthetic_error_visible_event,
@@ -65,10 +68,15 @@ class LoopStreamDriver:
                 self._observe_event(event)
                 yield event
             self.result.graph_completed = True
+        except asyncio.CancelledError as exc:
+            self.result.final_error = exc
+            for repair in self._orphan_tool_result_repairs(closeout_kind="cancelled"):
+                yield repair
+            raise
         except GraphRecursionError as exc:
             self.result.final_error = exc
             self._log_catch_error(exc)
-            for repair in self._orphan_tool_result_repairs():
+            for repair in self._orphan_tool_result_repairs(closeout_kind="interrupted"):
                 yield repair
             if not self.result.saw_error_visible_surface:
                 self.result.saw_error_visible_surface = True
@@ -99,7 +107,7 @@ class LoopStreamDriver:
             self.result.final_error = exc
             # CC catch 协议 §5.3.3：先记录日志 / 观测，再补 stream surface，最后 re-raise
             self._log_catch_error(exc)
-            for repair in self._orphan_tool_result_repairs():
+            for repair in self._orphan_tool_result_repairs(closeout_kind="interrupted"):
                 yield repair
             if not self.result.saw_error_visible_surface:
                 self.result.saw_error_visible_surface = True
@@ -147,20 +155,19 @@ class LoopStreamDriver:
             self._track_chat_model_end(event)
 
     def _track_tool_start(self, event: dict[str, Any]) -> None:
-        run_id = event.get("run_id")
-        if not run_id:
+        tool_call_id = ToolCallIdResolver.resolve_from_langgraph_tool_event(event)
+        if not tool_call_id:
             return
-        tool_call_id = str(run_id)
         self._pending_tool_calls[tool_call_id] = {
             "tool_name": str(event.get("name") or ""),
             "tool_call_id": tool_call_id,
         }
 
     def _track_tool_end(self, event: dict[str, Any]) -> None:
-        run_id = event.get("run_id")
-        if not run_id:
+        tool_call_id = ToolCallIdResolver.resolve_from_langgraph_tool_event(event)
+        if not tool_call_id:
             return
-        self._pending_tool_calls.pop(str(run_id), None)
+        self._pending_tool_calls.pop(tool_call_id, None)
 
     def _track_chat_model_end(self, event: dict[str, Any]) -> None:
         self._assistant_turn_count += 1
@@ -176,19 +183,33 @@ class LoopStreamDriver:
                     tool_use_count = len(raw_calls)
         self._last_tool_use_count = tool_use_count
 
-    def _orphan_tool_result_repairs(self) -> list[dict[str, Any]]:
+    def _orphan_tool_result_repairs(
+        self,
+        *,
+        closeout_kind: Literal["cancelled", "interrupted"] = "interrupted",
+    ) -> list[dict[str, Any]]:
+        if closeout_kind == "cancelled":
+            status = "cancelled"
+            summary = "tool result missing due to stream cancellation"
+            error_kind = "graph_cancelled"
+            message = "stream cancelled before tool_result was emitted"
+        else:
+            status = "interrupted"
+            summary = "tool result missing due to stream interruption"
+            error_kind = "graph_runtime_error"
+            message = "stream interrupted before tool_result was emitted"
         repairs: list[dict[str, Any]] = []
         for item in self._pending_tool_calls.values():
             repairs.append(
                 build_synthetic_orphan_tool_result_event(
                     tool_name=str(item.get("tool_name") or ""),
                     tool_call_id=str(item.get("tool_call_id") or ""),
-                    status="error",
-                    summary="tool result missing due to stream interruption",
+                    status=status,
+                    summary=summary,
                     payload=None,
                     error={
-                        "message": "stream interrupted before tool_result was emitted",
-                        "error_kind": "graph_runtime_error",
+                        "message": message,
+                        "error_kind": error_kind,
                     },
                 )
             )

{langchain-agentx-python-1.2.6 → langchain-agentx-python-1.2.8}/langchain_agentx/loop/subagent/runner.py

@@ -33,7 +33,7 @@ import logging
 import threading
 from concurrent.futures import Future
 from dataclasses import dataclass, field
-from typing import Any, Callable, Literal
+from typing import Any, Callable
 
 from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
 
@@ -54,6 +54,12 @@ from langchain_agentx.loop.message_contract import (
     to_record,
 )
 from langchain_agentx.observability.events.tool_call_id_resolver import ToolCallIdResolver
+from langchain_agentx.observability.events.tool_outcome_resolver import (
+    error_message_for_outcome,
+    resolve_explicit_outcome,
+    summary_and_payload_from_output,
+    trace_tool_call_status,
+)
 from langchain_agentx.loop.subagent.progress import (
     SubagentExecutionTrace,
     SubagentProgressEvent,
@@ -297,37 +303,6 @@ async def _handle_tool_start_event(
     return next_step, tool_name
 
 
-def _tool_end_summary_and_payload(data: dict[str, Any]) -> tuple[str, Any]:
-    """从 LangGraph ``on_tool_end`` data 取 summary/payload（仅 RuntimeTool artifact，无 output 降级）。"""
-    if "summary" in data:
-        return str(data.get("summary") or ""), data.get("payload")
-    output = data.get("output")
-    if output is None:
-        return "", None
-    from langchain_agentx.observability.events.langchain_agentx_event_adapter import (
-        LangGraphToLangchainAgentEventAdapter,
-    )
-
-    artifact = LangGraphToLangchainAgentEventAdapter._extract_artifact(output)
-    if artifact is not None:
-        return str(artifact.get("summary") or ""), artifact.get("payload")
-    return "", None
-
-
-def _is_tool_error(output: Any) -> bool:
-    """判断工具输出是否是错误。
-
-    参考 LangGraphToLangchainAgentEventAdapter._is_tool_error()。
-    """
-    if output is None:
-        return False
-    if isinstance(output, Exception):
-        return True
-    if isinstance(output, dict):
-        return bool(output.get("error") is not None or output.get("status") == "error")
-    return False
-
-
 async def _handle_tool_end_event(
     *,
     ctx: SubagentContext,
@@ -338,19 +313,30 @@ async def _handle_tool_end_event(
     trace: SubagentExecutionTrace | None = None,
 ) -> None:
     tool_name = event.get("name", "")
-    summary, payload = _tool_end_summary_and_payload(data)
+    output = data.get("output")
+    _artifact, terminal_state, business_status = resolve_explicit_outcome(output)
+    summary, payload = summary_and_payload_from_output(output)
+    trace_status = trace_tool_call_status(terminal_state, business_status)
+    error_message = error_message_for_outcome(
+        output,
+        terminal_state=terminal_state,
+        status=business_status,
+        tool_name=tool_name,
+    )
 
-    # 判断是否有错误
-    is_error = _is_tool_error(data.get("output"))
-    status: Literal["completed", "error"] = "error" if is_error else "completed"
+    if terminal_state is None or business_status is None:
+        logger.warning(
+            "subagent tool_end missing explicit artifact outcome tool=%s output_type=%s",
+            tool_name,
+            type(output).__name__,
+        )
 
-    # 更新执行轨迹中的最后一个工具调用状态
     if trace:
         trace.update_last_status(
-            status=status,
+            status=trace_status,
             summary=summary[:200] if summary else "",
             payload=str(payload)[:500] if payload is not None else None,
-            error_message=str(data.get("output"))[:200] if is_error else None,
+            error_message=error_message,
         )
 
     # 构建 transcript 内容：summary + payload（截断）