langchain-agentx-python 0.5.1__tar.gz → 0.5.3__tar.gz

{langchain-agentx-python-0.5.1 → langchain-agentx-python-0.5.3}/PKG-INFO

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

{langchain-agentx-python-0.5.1 → langchain-agentx-python-0.5.3}/langchain_agentx/__init__.py

@@ -11,12 +11,19 @@ from langchain_agentx import create_loop_agent
 ```
 """
 
-__version__ = "0.5.1"
+__version__ = "0.5.3"
 
 from .loop import (  # noqa: F401
     create_loop_agent,
 )
 
+from .loop.hook import (  # noqa: F401
+    ATTACHMENT_HOOK_BLOCKING_ERROR,
+    ATTACHMENT_HOOK_CANCELLED,
+    ATTACHMENT_HOOK_NON_BLOCKING_ERROR,
+    ATTACHMENT_HOOK_STOPPED_CONTINUATION,
+    ATTACHMENT_HOOK_SUCCESS,
+)
 from .observability import (  # noqa: F401
     EventAdapterState,
     LangchainAgentEvent,
@@ -31,6 +38,11 @@ from .session import AgentSession, create_agent_session  # noqa: F401
 from .workflow import BaseWorkflow  # noqa: F401
 
 __all__ = [
+    "ATTACHMENT_HOOK_BLOCKING_ERROR",
+    "ATTACHMENT_HOOK_CANCELLED",
+    "ATTACHMENT_HOOK_NON_BLOCKING_ERROR",
+    "ATTACHMENT_HOOK_STOPPED_CONTINUATION",
+    "ATTACHMENT_HOOK_SUCCESS",
     "create_loop_agent",
     "create_agent_session",
     "AgentSession",

{langchain-agentx-python-0.5.1 → langchain-agentx-python-0.5.3}/langchain_agentx/loop/exit/exit_logic.py

@@ -21,7 +21,7 @@ Agent Loop 退出逻辑与扩展状态定义。
 
 from __future__ import annotations
 
-from typing import Any, TypedDict
+from typing import Any, NotRequired, TypedDict
 
 from langchain_core.messages import AIMessage
 
@@ -260,6 +260,9 @@ class AgentLoopState(TypedDict):
     max_output_tokens_override: int | None  # max_output_tokens 升档参数
     max_output_tokens_recovery_count: int  # max_output_tokens 恢复计数
     __hook_result__: dict[str, Any] | None  # 新 Hook 聚合结果（loop_controller 首选读取）
+    _hook_ui_events: NotRequired[
+        list[dict[str, Any]]
+    ]  # per-script UI 事件队列；节点 patch 替换，非 add_messages 累积
     _hook_engine: Any | None  # Hook 引擎实例（hook 节点/edge 读取）
     _hook_runner: Any | None  # Hook 执行协作者（hook 节点/edge 读取）
     _session_env: dict[str, str]  # SESSION_START hook 注入的会话级环境变量

{langchain-agentx-python-0.5.1 → langchain-agentx-python-0.5.3}/langchain_agentx/loop/graph/graph_edges.py

@@ -34,6 +34,7 @@ from langgraph.graph.state import StateGraph
 from langgraph.prebuilt.tool_node import ToolCallWithContext, ToolNode
 from langgraph.types import Send
 from ..hook.async_hook_runner import AsyncHookRunner
+from ..hook.hook_projection import hook_result_to_event_dict
 from ..hook.types import HookContext, HookEvent
 
 # 导入事件发射器（CLI Phase 1A 骨架）
@@ -84,6 +85,7 @@ def _execute_hook_common(
     tool_name: str | None = None,
     tool_input: dict[str, Any] | None = None,
     tool_result: Any = None,
+    tool_call_id: str | None = None,
 ) -> dict[str, Any] | None:
     hook_engine = state.get("_hook_engine")
     if hook_engine is None:
@@ -102,15 +104,21 @@ def _execute_hook_common(
         ctx_kwargs["tool_input"] = tool_input
     if tool_result is not None:
         ctx_kwargs["tool_result"] = tool_result
+    if tool_call_id is not None:
+        ctx_kwargs["tool_call_id"] = tool_call_id
     ctx = HookContext(**ctx_kwargs)
     result = hook_runner.run(hook_engine, ctx)
-    return {
-        "prevent_continuation": bool(result.prevent_continuation),
-        "blocking_errors": list(result.blocking_errors) or None,
-        "permission_behavior": result.permission_behavior,
-        "hook_permission_decision_reason": result.hook_permission_decision_reason,
-        "updated_input": result.updated_input,
-    }
+    hook_dict = hook_result_to_event_dict(
+        result,
+        tool_call_id=tool_call_id,
+    )
+    emitter = getattr(hook_engine, "_event_emitter", None)
+    if emitter is not None and hasattr(emitter, "drain_ui_events"):
+        pending = emitter.drain_ui_events()
+        if pending:
+            # 每次 hook 调用替换列表（非累积）；LangGraph 对未注解键为 last-write-wins
+            state["_hook_ui_events"] = pending
+    return hook_dict
 
 
 def _execute_hook_for_tool(
@@ -120,6 +128,7 @@ def _execute_hook_for_tool(
     tool_name: str,
     tool_input: dict[str, Any] | None,
     tool_result: Any = None,
+    tool_call_id: str | None = None,
 ) -> dict[str, Any] | None:
     return _execute_hook_common(
         state,
@@ -127,6 +136,7 @@ def _execute_hook_for_tool(
         tool_name=tool_name,
         tool_input=tool_input,
         tool_result=tool_result,
+        tool_call_id=tool_call_id,
     )
 
 
@@ -679,6 +689,7 @@ class LoopControllerEdge:
             event=HookEvent.PRE_TOOL_USE,
             tool_name=tool_name,
             tool_input=tool_args if isinstance(tool_args, dict) else {},
+            tool_call_id=str(tool_call.get("id") or "") or None,
         )
         next_tool_call = tool_call
         blocked_message: ToolMessage | None = None
@@ -812,6 +823,7 @@ def _make_tools_to_model_edge(
                     tool_name=str(tc.get("name") or ""),
                     tool_input=tc.get("args") if isinstance(tc.get("args"), dict) else {},
                     tool_result=getattr(tm, "content", None),
+                    tool_call_id=str(getattr(tm, "tool_call_id", "") or "") or None,
                 )
                 if isinstance(hook_result, dict):
                     state["__hook_result__"] = hook_result

{langchain-agentx-python-0.5.1 → langchain-agentx-python-0.5.3}/langchain_agentx/loop/hook/__init__.py

@@ -15,7 +15,16 @@ from .config import HookCandidate, HookCandidateDecision, HookSpec, HooksConfigS
 from .async_hook_runner import AsyncHookRunner
 from .engine import HookEngine
 from .executors import AgentExecutor, CommandExecutor, HttpExecutor, PromptExecutor
-from .graph_wiring import HookGraphWiring
+from .graph_wiring import HookGraphWiring, derive_hook_outcome
+from .hook_projection import (
+    ATTACHMENT_HOOK_BLOCKING_ERROR,
+    ATTACHMENT_HOOK_CANCELLED,
+    ATTACHMENT_HOOK_NON_BLOCKING_ERROR,
+    ATTACHMENT_HOOK_STOPPED_CONTINUATION,
+    ATTACHMENT_HOOK_SUCCESS,
+    derive_attachment_type,
+    hook_result_to_event_dict,
+)
 from .registry import HookRegistry
 from .trust import WorkspaceTrustChecker
 from .types import (
@@ -27,6 +36,11 @@ from .types import (
 )
 
 __all__ = [
+    "ATTACHMENT_HOOK_BLOCKING_ERROR",
+    "ATTACHMENT_HOOK_CANCELLED",
+    "ATTACHMENT_HOOK_NON_BLOCKING_ERROR",
+    "ATTACHMENT_HOOK_STOPPED_CONTINUATION",
+    "ATTACHMENT_HOOK_SUCCESS",
     "AggregatedHookResult",
     "AsyncHookRunner",
     "HookCandidate",
@@ -45,4 +59,7 @@ __all__ = [
     "PromptExecutor",
     "AgentExecutor",
     "WorkspaceTrustChecker",
+    "derive_attachment_type",
+    "derive_hook_outcome",
+    "hook_result_to_event_dict",
 ]

{langchain-agentx-python-0.5.1 → langchain-agentx-python-0.5.3}/langchain_agentx/loop/hook/engine.py

@@ -37,6 +37,7 @@ from .types import (
     HookResult,
     PermissionBehavior,
 )
+from .hook_projection import build_hook_info
 from .trust import WorkspaceTrustChecker
 
 if TYPE_CHECKING:
@@ -97,6 +98,7 @@ class HookEngine:
         self._trust_checker = trust_checker
 
     async def execute(self, ctx: HookContext) -> AggregatedHookResult:
+        batch_started_at = time.perf_counter()
         candidates, skipped = self._snapshot.get_candidates_with_decisions(ctx)
         self._emit_skipped_records(ctx, skipped)
         if not candidates:
@@ -119,15 +121,23 @@ class HookEngine:
         ]
 
         for candidate in sequential_candidates:
-            one = await self._run_with_record(candidate, ctx)
+            one = await self._run_with_record(candidate, ctx, result)
             self._merge(result, one)
 
         if parallel_candidates:
-            parallel_results = await asyncio.gather(
-                *(self._run_with_record(candidate, ctx) for candidate in parallel_candidates)
+
+            async def _run_parallel(candidate: HookCandidate) -> tuple[HookResult, AggregatedHookResult]:
+                local = AggregatedHookResult()
+                one = await self._run_with_record(candidate, ctx, local)
+                return one, local
+
+            pairs = await asyncio.gather(
+                *(_run_parallel(candidate) for candidate in parallel_candidates)
             )
-            for one in parallel_results:
+            for one, local in pairs:
                 self._merge(result, one)
+                result.hook_infos.extend(local.hook_infos)
+        result.duration_ms = (time.perf_counter() - batch_started_at) * 1000
         return result
 
     def _filter_trusted_candidates(
@@ -144,11 +154,55 @@ class HookEngine:
             trusted.append(candidate)
         return trusted
 
-    async def _run_with_record(self, candidate: HookCandidate, ctx: HookContext) -> HookResult:
+    async def _run_with_record(
+        self,
+        candidate: HookCandidate,
+        ctx: HookContext,
+        agg: AggregatedHookResult,
+    ) -> HookResult:
+        hook_name = str(candidate.spec.config.get("name") or candidate.spec.hook_id)
+        if self._event_emitter is not None:
+            self._event_emitter.emit_progress(
+                {
+                    "hook_id": candidate.spec.hook_id,
+                    "hook_name": hook_name,
+                    "hook_event": ctx.event.value,
+                    "tool_call_id": ctx.tool_call_id,
+                    "session_id": ctx.session_id,
+                    "node_level": False,
+                    "phase": "running",
+                }
+            )
         started_at = time.perf_counter()
         one = await self._run_one(candidate, ctx)
         duration_ms = (time.perf_counter() - started_at) * 1000
         outcome = self._emit_execution_record(ctx, candidate, one, duration_ms)
+        info = build_hook_info(
+            hook_id=candidate.spec.hook_id,
+            hook_event=ctx.event.value,
+            config=candidate.spec.config,
+            outcome=outcome,  # type: ignore[arg-type]
+            duration_ms=duration_ms,
+            stdout=one.stdout,
+            stderr=one.stderr,
+            exit_code=one.exit_code,
+            prevent_continuation=one.prevent_continuation,
+            blocking_errors=list(one.blocking_errors) or None,
+            tool_call_id=ctx.tool_call_id,
+        )
+        agg.hook_infos.append(info)
+        agg.duration_ms += duration_ms
+        if self._event_emitter is not None:
+            self._event_emitter.emit_response(
+                {
+                    **info,
+                    "combined_stdout": one.stdout,
+                    "combined_stderr": one.stderr,
+                    "node_level": False,
+                    "phase": "finished",
+                    "session_id": ctx.session_id,
+                }
+            )
         if outcome == "success" and candidate.spec.on_success is not None:
             candidate.spec.on_success()
         return one
@@ -245,6 +299,10 @@ class HookEngine:
             outcome=outcome,
             prevent_continuation=result.prevent_continuation,
             duration_ms=duration_ms,
+            tool_call_id=ctx.tool_call_id,
+            stdout=result.stdout,
+            stderr=result.stderr,
+            exit_code=result.exit_code,
         )
         self._try_emit_record(ctx.session_id, record)
         return outcome

{langchain-agentx-python-0.5.1 → langchain-agentx-python-0.5.3}/langchain_agentx/loop/hook/graph_wiring.py

@@ -19,26 +19,17 @@ 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 .types import AggregatedHookResult, HookContext, HookEvent
 
 
-def _to_hook_result_dict(result: AggregatedHookResult) -> dict[str, Any]:
-    """将 AggregatedHookResult 转换为字典，包含 Hook 输出结果（stdout/stderr/exit_code）。"""
-    return {
-        "prevent_continuation": result.prevent_continuation,
-        "blocking_errors": list(result.blocking_errors) or None,
-        "permission_behavior": result.permission_behavior,
-        "hook_permission_decision_reason": result.hook_permission_decision_reason,
-        "additional_contexts": list(result.additional_contexts),
-        "updated_input": result.updated_input,
-        "state_patch": dict(result.state_patch),
-        # Hook 输出结果（对齐 CC hook_response）
-        "stdouts": list(result.stdouts) or None,
-        "stderrs": list(result.stderrs) or None,
-        "exit_codes": list(result.exit_codes) or None,
-        "combined_stdout": result.combined_stdout or None,
-        "combined_stderr": result.combined_stderr or None,
-    }
+def _to_hook_result_dict(
+    result: AggregatedHookResult,
+    *,
+    tool_call_id: str | None = None,
+) -> dict[str, Any]:
+    """兼容别名：图节点 __hook_result__ 与事件 adapter 共用投影。"""
+    return hook_result_to_event_dict(result, tool_call_id=tool_call_id)
 
 
 @dataclass
@@ -71,6 +62,7 @@ class HookGraphWiring:
         result = self._execute_sync(HookEvent.LOOP_START, state_with_run_id)
         if result is not None:
             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))
         return patch
@@ -78,8 +70,10 @@ class HookGraphWiring:
     def before_model_node(self, state: dict[str, Any], runtime: Any) -> dict[str, Any]:
         result = self._execute_sync(HookEvent.BEFORE_MODEL, state)
         patch = {"__hook_result__": _to_hook_result_dict(result)} if result is not None else {}
-        if result is not None and result.state_patch:
-            patch.update(dict(result.state_patch))
+        if result is not None:
+            patch.update(self._drain_hook_ui_events())
+            if result.state_patch:
+                patch.update(dict(result.state_patch))
         if self.trace_lifecycle_collector is not None:
             patch.update(self.trace_lifecycle_collector.before_model_node(state))
         return patch
@@ -87,8 +81,10 @@ class HookGraphWiring:
     def after_model_node(self, state: dict[str, Any], runtime: Any) -> dict[str, Any]:
         result = self._execute_sync(HookEvent.AFTER_MODEL, state)
         patch = {"__hook_result__": _to_hook_result_dict(result)} if result is not None else {}
-        if result is not None and result.state_patch:
-            patch.update(dict(result.state_patch))
+        if result is not None:
+            patch.update(self._drain_hook_ui_events())
+            if result.state_patch:
+                patch.update(dict(result.state_patch))
         if self.session_memory is not None:
             self.session_memory.maybe_trigger(state)
         if self.trace_lifecycle_collector is not None:
@@ -118,6 +114,7 @@ class HookGraphWiring:
         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))
         return patch
@@ -125,8 +122,10 @@ class HookGraphWiring:
     def loop_end_node(self, state: dict[str, Any], runtime: Any) -> dict[str, Any]:
         result = self._execute_sync(HookEvent.LOOP_END, state)
         patch = {"__hook_result__": _to_hook_result_dict(result)} if result is not None else {}
-        if result is not None and result.state_patch:
-            patch.update(dict(result.state_patch))
+        if result is not None:
+            patch.update(self._drain_hook_ui_events())
+            if result.state_patch:
+                patch.update(dict(result.state_patch))
         if self.trace_lifecycle_collector is not None:
             patch.update(self.trace_lifecycle_collector.loop_end_node(state))
         return patch
@@ -137,5 +136,14 @@ class HookGraphWiring:
         ctx = HookContext(event=event, state=state, session_id=state.get("_run_id"))
         return self.hook_runner.run(self.hook_engine, ctx)
 
+    def _drain_hook_ui_events(self) -> dict[str, Any]:
+        emitter = getattr(self.hook_engine, "_event_emitter", None)
+        if emitter is None or not hasattr(emitter, "drain_ui_events"):
+            return {}
+        pending = emitter.drain_ui_events()
+        if not pending:
+            return {}
+        return {"_hook_ui_events": pending}
+
 
-__all__ = ["HookGraphWiring"]
+__all__ = ["HookGraphWiring", "_to_hook_result_dict", "derive_hook_outcome"]

langchain-agentx-python-0.5.3/langchain_agentx/loop/hook/hook_projection.py

@@ -0,0 +1,164 @@
+"""
+hook_projection.py — Hook 结果到 LangchainAgent 事件的 SDK 侧投影（对齐 CC attachment / hook_response）。
+
+职责：
+    集中推导 outcome、attachment_type，并将 AggregatedHookResult / 单 hook 执行信息转为事件 data dict。
+
+链路位置：
+    graph_wiring、graph_edges、HookEventEmitter、langchain_agentx_event_adapter 共用。
+
+当前裁剪范围：
+    仅结构化投影；不做 CLI 展示决策。
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .types import AggregatedHookResult, HookOutcome
+
+AttachmentType = str
+
+ATTACHMENT_HOOK_SUCCESS = "hook_success"
+ATTACHMENT_HOOK_BLOCKING_ERROR = "hook_blocking_error"
+ATTACHMENT_HOOK_NON_BLOCKING_ERROR = "hook_non_blocking_error"
+ATTACHMENT_HOOK_STOPPED_CONTINUATION = "hook_stopped_continuation"
+ATTACHMENT_HOOK_CANCELLED = "hook_cancelled"
+
+
+def derive_hook_outcome(result: AggregatedHookResult) -> HookOutcome:
+    """从聚合结果推导 outcome（与 HookEngine._emit_execution_record 语义对齐）。"""
+    if result.prevent_continuation or result.blocking_errors:
+        return "blocking"
+    if any(code != 0 for code in result.exit_codes):
+        return "non_blocking_error"
+    return "success"
+
+
+def derive_attachment_type(
+    result: AggregatedHookResult,
+    outcome: HookOutcome | None = None,
+) -> AttachmentType:
+    """推导 CC 风格 attachment_type（CLI 仅据此选控件）。"""
+    resolved = outcome or derive_hook_outcome(result)
+    if result.prevent_continuation and not result.blocking_errors:
+        return ATTACHMENT_HOOK_STOPPED_CONTINUATION
+    if resolved == "blocking" or result.blocking_errors:
+        return ATTACHMENT_HOOK_BLOCKING_ERROR
+    if resolved == "non_blocking_error":
+        return ATTACHMENT_HOOK_NON_BLOCKING_ERROR
+    if resolved == "cancelled":
+        return ATTACHMENT_HOOK_CANCELLED
+    return ATTACHMENT_HOOK_SUCCESS
+
+
+def hook_display_name(hook_id: str, hook_event: str, config: dict[str, Any]) -> str:
+    """对齐 CC ``hookEvent:matcher`` 展示名（config.name 优先）。"""
+    name = config.get("name")
+    if isinstance(name, str) and name.strip():
+        return name.strip()
+    return hook_id or hook_event
+
+
+def derive_attachment_type_for_hook(
+    *,
+    outcome: HookOutcome,
+    prevent_continuation: bool = False,
+    blocking_errors: list[str] | None = None,
+    exit_codes: list[int] | None = None,
+) -> AttachmentType:
+    """单条 hook 的 attachment_type（避免为 build_hook_info 构造假 AggregatedHookResult）。"""
+    blocking = list(blocking_errors or [])
+    if prevent_continuation and not blocking:
+        return ATTACHMENT_HOOK_STOPPED_CONTINUATION
+    if outcome == "blocking" or blocking:
+        return ATTACHMENT_HOOK_BLOCKING_ERROR
+    if outcome == "non_blocking_error" or any(
+        code != 0 for code in (exit_codes or [])
+    ):
+        return ATTACHMENT_HOOK_NON_BLOCKING_ERROR
+    if outcome == "cancelled":
+        return ATTACHMENT_HOOK_CANCELLED
+    return ATTACHMENT_HOOK_SUCCESS
+
+
+def build_hook_info(
+    *,
+    hook_id: str,
+    hook_event: str,
+    config: dict[str, Any],
+    outcome: HookOutcome,
+    duration_ms: float,
+    stdout: str | None = None,
+    stderr: str | None = None,
+    exit_code: int | None = None,
+    prevent_continuation: bool = False,
+    blocking_errors: list[str] | None = None,
+    tool_call_id: str | None = None,
+) -> dict[str, Any]:
+    """单条 hook 执行明细（STOP 批次 summary / hook_infos[]）。"""
+    return {
+        "hook_id": hook_id,
+        "hook_name": hook_display_name(hook_id, hook_event, config),
+        "hook_event": hook_event,
+        "outcome": outcome,
+        "duration_ms": duration_ms,
+        "stdout": stdout,
+        "stderr": stderr,
+        "exit_code": exit_code,
+        "prevent_continuation": prevent_continuation,
+        "blocking_errors": list(blocking_errors) if blocking_errors else None,
+        "tool_call_id": tool_call_id,
+        "attachment_type": derive_attachment_type_for_hook(
+            outcome=outcome,
+            prevent_continuation=prevent_continuation,
+            blocking_errors=blocking_errors,
+            exit_codes=[exit_code] if exit_code is not None else None,
+        ),
+    }
+
+
+def hook_result_to_event_dict(
+    result: AggregatedHookResult,
+    *,
+    tool_call_id: str | None = None,
+) -> dict[str, Any]:
+    """将 AggregatedHookResult 转为 HOOK_FINISHED / 图节点 __hook_result__ 契约。"""
+    outcome = derive_hook_outcome(result)
+    payload: dict[str, Any] = {
+        "outcome": outcome,
+        "attachment_type": derive_attachment_type(result, outcome),
+        "prevent_continuation": result.prevent_continuation,
+        "blocking_errors": list(result.blocking_errors) or None,
+        "permission_behavior": result.permission_behavior,
+        "hook_permission_decision_reason": result.hook_permission_decision_reason,
+        "additional_contexts": list(result.additional_contexts) or None,
+        "updated_input": result.updated_input,
+        "state_patch": dict(result.state_patch) or None,
+        "stdouts": list(result.stdouts) or None,
+        "stderrs": list(result.stderrs) or None,
+        "exit_codes": list(result.exit_codes) or None,
+        "combined_stdout": result.combined_stdout or None,
+        "combined_stderr": result.combined_stderr or None,
+        "duration_ms": result.duration_ms if result.duration_ms > 0 else None,
+        "hook_infos": list(result.hook_infos) or None,
+    }
+    if tool_call_id:
+        payload["tool_call_id"] = tool_call_id
+    return payload
+
+
+__all__ = [
+    "ATTACHMENT_HOOK_BLOCKING_ERROR",
+    "ATTACHMENT_HOOK_CANCELLED",
+    "ATTACHMENT_HOOK_NON_BLOCKING_ERROR",
+    "ATTACHMENT_HOOK_STOPPED_CONTINUATION",
+    "ATTACHMENT_HOOK_SUCCESS",
+    "AttachmentType",
+    "build_hook_info",
+    "derive_attachment_type",
+    "derive_attachment_type_for_hook",
+    "derive_hook_outcome",
+    "hook_display_name",
+    "hook_result_to_event_dict",
+]

{langchain-agentx-python-0.5.1 → langchain-agentx-python-0.5.3}/langchain_agentx/loop/hook/types.py

@@ -57,6 +57,7 @@ class HookContext:
     - tool_name: 工具名称
     - tool_input: 工具输入参数
     - tool_result: 工具执行结果
+    - tool_call_id: LangGraph / LLM 工具调用 ID（PRE/POST 工具 hook）
     - workflow_id: Workflow ID（用于 Workflow 级事件）
     - workflow_session_id: Workflow 唯一会话 ID（Phase 1 新增）
     - workflow_path: Workflow 层级路径（Phase 1 新增）
@@ -81,6 +82,7 @@ class HookContext:
     tool_name: str | None = None
     tool_input: dict[str, Any] | None = None
     tool_result: Any = None
+    tool_call_id: str | None = None
 
     # === Workflow 级字段（Phase 1）===
     workflow_id: str | None = None
@@ -107,6 +109,10 @@ class HookExecutionRecord:
     outcome: HookOutcome
     prevent_continuation: bool
     duration_ms: float
+    tool_call_id: str | None = None
+    stdout: str | None = None
+    stderr: str | None = None
+    exit_code: int | None = None
 
 
 @dataclass
@@ -145,6 +151,9 @@ class AggregatedHookResult:
     # 合并后的完整输出（用于事件展示）
     combined_stdout: str = ""
     combined_stderr: str = ""
+    # 批次级：单 hook 明细（对齐 CC stop_hook_summary / hook_infos）
+    hook_infos: list[dict[str, Any]] = field(default_factory=list)
+    duration_ms: float = 0.0
 
 
 __all__ = [