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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-agentx-python
-Version: 1.2.6
+Version: 1.2.7
 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.7}/langchain_agentx/__init__.py

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

{langchain-agentx-python-1.2.6 → langchain-agentx-python-1.2.7}/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.7}/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（截断）

{langchain-agentx-python-1.2.6 → langchain-agentx-python-1.2.7}/langchain_agentx/observability/events/langchain_agentx_event_adapter.py

@@ -13,15 +13,15 @@ LangChain AgentX Event Adapter
 docs/design-docs/observability/event-system.md 中「CC 对齐：事件层改进方向」。
 
 TOOL_RESULT / TOOL_ERROR 事件 data（SDK 内置工具，v1）：
-    所有工具必须是 RuntimeTool，均通过 _build_langchain_tool 构建，因此都有 artifact。
-    事件 data 直接平铺 artifact 的结构化字段（summary / status / payload / meta /
-    blocks / hints / artifacts / error / truncated / overflow_file / schema_version / display），
-    不再保留冗余的 output 字段。详见 tool-result-dual-path.md。
+    所有 RuntimeTool 路径必须在 ToolMessage.artifact 中携带 status / terminal_state；
+    事件 data 平铺 artifact 结构化字段，禁止从 output 文本推断 outcome。
+    缺失 artifact.status 时 emit TOOL_ERROR（terminal_state=crashed, error_type=protocol_violation）。
 """
 
 from __future__ import annotations
 
 import json
+import logging
 import time
 from dataclasses import dataclass, field
 from enum import Enum
@@ -37,6 +37,12 @@ from langchain_agentx.observability.events.finish_event_payload_composer import
 from langchain_agentx.observability.events.tool_call_id_resolver import (
     ToolCallIdResolver,
 )
+from langchain_agentx.observability.events.tool_outcome_resolver import (
+    extract_artifact,
+    is_synthetic_orphan_success,
+    normalize_synthetic_orphan_outcome,
+    resolve_explicit_outcome,
+)
 from langchain_agentx.observability.events.subagent_event_mapper import (
     SubagentBoundaryPayloadBuilder,
     SubagentProgressEventMapper,
@@ -46,6 +52,7 @@ from langchain_agentx.observability.events.subagent_event_mapper import (
 _ARTIFACT_V1_EVENT_FIELDS: tuple[str, ...] = (
     "schema_version",
     "status",
+    "terminal_state",
     "tool_name",
     "summary",
     "payload",
@@ -58,6 +65,8 @@ _ARTIFACT_V1_EVENT_FIELDS: tuple[str, ...] = (
     "overflow_file",
 )
 
+logger = logging.getLogger(__name__)
+
 
 class LangchainAgentEventType(Enum):
     # 会话级别
@@ -711,57 +720,16 @@ class LangGraphToLangchainAgentEventAdapter:
             return "".join(parts)
         return str(content) if content is not None else ""
 
-    def _extract_tool_result_text(self, output: Any) -> str:
-        """多层降级提取工具结果正文，避免打印 ToolMessage/Envelope 的完整 repr。
-
-        降级顺序：.content → .payload → .summary → dict 键查找 → str() 兜底
-        """
-        if output is None:
-            return ""
-        if isinstance(output, str):
-            return output
-        content = getattr(output, "content", None)
-        if content is not None:
-            return self._extract_text_from_message_content(content)
-        payload = getattr(output, "payload", None)
-        if payload is not None:
-            return str(payload)
-        summary = getattr(output, "summary", None)
-        if isinstance(summary, str) and summary:
-            return summary
-        if isinstance(output, dict):
-            for key in ("payload", "content", "summary", "output"):
-                if key in output:
-                    return str(output[key])
-        return str(output)
-
     @staticmethod
     def _extract_artifact(output: Any) -> dict[str, Any] | None:
         """从 ToolMessage / dict 提取 artifact；必须是 dict 才返回。"""
-        art = getattr(output, "artifact", None)
-        if isinstance(art, dict):
-            return art
-        if isinstance(output, dict):
-            nested = output.get("artifact")
-            if isinstance(nested, dict):
-                return nested
-        return None
+        return extract_artifact(output)
 
     @classmethod
     def _flatten_artifact_v1_fields(cls, artifact: dict[str, Any]) -> dict[str, Any]:
         """将 artifact v1 字段平铺进 event.data（值允许为 None）。"""
         return {key: artifact.get(key) for key in _ARTIFACT_V1_EVENT_FIELDS}
 
-    def _merge_artifact_into_event_data(
-        self, event_data: dict[str, Any], output: Any
-    ) -> None:
-        artifact = self._extract_artifact(output)
-        if artifact is not None:
-            event_data.update(self._flatten_artifact_v1_fields(artifact))
-            display = artifact.get("display")
-            if display is not None:
-                event_data["display"] = display
-
     @staticmethod
     def _extract_child_session_id_from_tool_output(output: Any) -> str | None:
         """Subagent：优先 artifact.meta，再降级 dict.meta / session_id。"""
@@ -1256,52 +1224,17 @@ class LangGraphToLangchainAgentEventAdapter:
 
         output = data.get("output")
 
-        # 判断是否是错误
-        is_error = self._is_tool_error(output)
-
-        if is_error:
-            error_data: dict[str, Any] = {
-                "tool_name": name,
-                "error": (
-                    str(output)
-                    if isinstance(output, Exception)
-                    else self._extract_tool_result_text(output)
-                ),
-                "error_type": self._get_error_type(output),
-                "status": "blocked" if isinstance(output, PermissionError) else "error",
-            }
-            self._merge_artifact_into_event_data(error_data, output)
-            ToolCallIdResolver.promote_to_event_data(error_data, fallback=tool_call_id)
-            yield self._event(
-                event_type=LangchainAgentEventType.TOOL_ERROR,
-                data=error_data,
-                step_index=self.state.step_index,
-                tool_name=name,
-            )
-        else:
-            # 直接使用 artifact 的结构化字段，不再保留冗余的 output 字段
-            artifact = self._extract_artifact(output)
-            if artifact is not None:
-                # artifact 存在：直接平铺其 v1 字段到 event.data
-                result_data = {"tool_name": name}
-                result_data.update(self._flatten_artifact_v1_fields(artifact))
-                # display 字段单独处理（不在 _ARTIFACT_V1_EVENT_FIELDS 中）
-                if "display" in artifact:
-                    result_data["display"] = artifact["display"]
-            else:
-                # artifact 不存在（兜底）：降级到提取文本（仅用于非 RuntimeTool 场景）
-                result_data: dict[str, Any] = {
-                    "tool_name": name,
-                    "summary": self._extract_tool_result_text(output),
-                    "status": "ok",
-                }
-            ToolCallIdResolver.promote_to_event_data(result_data, fallback=tool_call_id)
-            yield self._event(
-                event_type=LangchainAgentEventType.TOOL_RESULT,
-                data=result_data,
-                step_index=self.state.step_index,
-                tool_name=name,
-            )
+        event_type, event_data = self._classify_tool_end_event(
+            tool_name=name,
+            output=output,
+            tool_call_id=tool_call_id,
+        )
+        yield self._event(
+            event_type=event_type,
+            data=event_data,
+            step_index=self.state.step_index,
+            tool_name=name,
+        )
         if self.enable_subagent_events and self._is_agent_tool(name):
             child_session_id = self._extract_child_session_id_from_tool_output(output)
             agent_id, subagent_type = self._pop_subagent_boundary_snapshot(tool_call_id)
@@ -1321,25 +1254,96 @@ class LangGraphToLangchainAgentEventAdapter:
 
         self.state.current_tool = None
 
-    def _is_tool_error(self, output: Any) -> bool:
-        """判断工具输出是否是错误"""
-        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
+    def _resolve_tool_outcome_from_output(
+        self,
+        output: Any,
+    ) -> tuple[dict[str, Any] | None, str | None, str | None]:
+        """从 artifact 解析显式 (artifact, terminal_state, status)；无法解析时返回 (None, None, None)。"""
+        return resolve_explicit_outcome(output)
 
-    def _get_error_type(self, output: Any) -> str:
-        """获取错误类型"""
-        if isinstance(output, PermissionError):
-            return "permission_denied"
-        if isinstance(output, TimeoutError):
-            return "timeout"
-        if isinstance(output, ValueError):
-            return "invalid_input"
-        return "unknown"
+    def _classify_tool_end_event(
+        self,
+        *,
+        tool_name: str,
+        output: Any,
+        tool_call_id: str,
+    ) -> tuple[LangchainAgentEventType, dict[str, Any]]:
+        artifact, terminal_state, status = self._resolve_tool_outcome_from_output(output)
+        if terminal_state is not None and status is not None:
+            return self._event_data_from_explicit_outcome(
+                tool_name=tool_name,
+                tool_call_id=tool_call_id,
+                artifact=artifact,
+                terminal_state=terminal_state,
+                status=status,
+            )
+        return self._tool_end_protocol_violation_event(
+            tool_name=tool_name,
+            tool_call_id=tool_call_id,
+            output=output,
+        )
+
+    def _tool_end_protocol_violation_event(
+        self,
+        *,
+        tool_name: str,
+        tool_call_id: str,
+        output: Any,
+    ) -> tuple[LangchainAgentEventType, dict[str, Any]]:
+        """RuntimeTool 主路径要求 artifact.status；缺失时视为协议违例。"""
+        logger.warning(
+            "tool_end missing explicit artifact outcome tool=%s output_type=%s",
+            tool_name,
+            type(output).__name__,
+        )
+        event_data: dict[str, Any] = {
+            "tool_name": tool_name,
+            "status": "error",
+            "terminal_state": "crashed",
+            "error_type": "protocol_violation",
+            "error": "tool_end output missing artifact.status",
+        }
+        ToolCallIdResolver.promote_to_event_data(event_data, fallback=tool_call_id)
+        return LangchainAgentEventType.TOOL_ERROR, event_data
+
+    def _event_data_from_explicit_outcome(
+        self,
+        *,
+        tool_name: str,
+        tool_call_id: str,
+        artifact: dict[str, Any] | None,
+        terminal_state: str,
+        status: str,
+    ) -> tuple[LangchainAgentEventType, dict[str, Any]]:
+        if terminal_state == "completed" and status == "ok":
+            event_type = LangchainAgentEventType.TOOL_RESULT
+        else:
+            event_type = LangchainAgentEventType.TOOL_ERROR
+
+        event_data: dict[str, Any] = {"tool_name": tool_name}
+        if artifact is not None:
+            event_data.update(self._flatten_artifact_v1_fields(artifact))
+            display = artifact.get("display")
+            if display is not None:
+                event_data["display"] = display
+        event_data["tool_name"] = tool_name
+        event_data["terminal_state"] = terminal_state
+        event_data["status"] = status
+
+        if event_type == LangchainAgentEventType.TOOL_ERROR:
+            if terminal_state == "cancelled":
+                event_data.setdefault("error_type", "cancelled")
+            elif terminal_state == "crashed":
+                event_data.setdefault("error_type", "runtime_crashed")
+            elif status == "blocked":
+                event_data.setdefault("error_type", "permission_denied")
+            if "error" not in event_data:
+                summary = event_data.get("summary")
+                if isinstance(summary, str) and summary:
+                    event_data["error"] = summary
+
+        ToolCallIdResolver.promote_to_event_data(event_data, fallback=tool_call_id)
+        return event_type, event_data
 
     # ===== Error 事件处理 =====
 
@@ -1368,7 +1372,7 @@ class LangGraphToLangchainAgentEventAdapter:
         当工具通过 ctx.emit_progress() 或子 Agent 通过 adispatch_custom_event
         发射进度事件时，这些事件会通过主 graph 的 astream_events 流冒泡上来。
 
-        事件格式（tool_progress，主 agent 工具）：
+        事件格式（tool_progress，子 agent / 主 agent 工具进度）：
         {
             "event": "on_custom_event",
             "name": "tool_progress",
@@ -1376,23 +1380,10 @@ class LangGraphToLangchainAgentEventAdapter:
                 "tool_name": str,
                 "tool_call_id": str,
                 "agent_id": str,
-                "phase": str,  # 如 "running", "query_update", "search_results_received"
-                "data": dict,  # 工具特定的业务数据
-            }
-        }
-
-        事件格式（subagent_progress，子 agent 事件）：
-        {
-            "event": "on_custom_event",
-            "name": "subagent_progress",
-            "data": {
-                "type": "tool_use" | "tool_result" | "model_step" | "completed",
-                "subagent_type": str,
-                "agent_id": str,
-                "tool_name": str,
+                "phase": str,  # 如 "tool_use", "tool_result", "running"
                 "summary": str,
                 "step": int,
-                "parent_tool_use_id": str,
+                "data": dict,
             }
         }
         """
@@ -1469,20 +1460,22 @@ class LangGraphToLangchainAgentEventAdapter:
             data = event.get("data", {})
             if not isinstance(data, dict):
                 return
-            status = str(data.get("status") or "completed")
+            raw_status = str(data.get("status") or "interrupted")
+            business_status, terminal_state = normalize_synthetic_orphan_outcome(raw_status)
             event_data = {
                 "tool_name": str(data.get("tool_name") or ""),
                 "summary": data.get("summary"),
                 "payload": data.get("payload"),
                 "error": data.get("error"),
-                "status": status,
+                "status": business_status,
+                "terminal_state": terminal_state,
                 "meta": data.get("meta") or {},
                 "tool_call_id": data.get("tool_call_id") or "",
             }
             target_type = (
-                LangchainAgentEventType.TOOL_ERROR
-                if status == "error"
-                else LangchainAgentEventType.TOOL_RESULT
+                LangchainAgentEventType.TOOL_RESULT
+                if is_synthetic_orphan_success(raw_status)
+                else LangchainAgentEventType.TOOL_ERROR
             )
             yield self._event(
                 event_type=target_type,
@@ -1564,22 +1557,6 @@ class LangGraphToLangchainAgentEventAdapter:
         if not self.enable_subagent_events:
             return
 
-        # 遗留 subagent_progress（runner 已改用 tool_progress；保留兼容）
-        if event_name == "subagent_progress":
-            data = event.get("data", {})
-            if not isinstance(data, dict):
-                return
-            mapped = SubagentProgressEventMapper.map_legacy_subagent_progress(data)
-            if mapped is None:
-                return
-            yield self._event(
-                event_type=mapped.event_type,
-                data=mapped.data,
-                step_index=self.state.step_index,
-                tool_name=mapped.tool_name,
-            )
-            return
-
 
 __all__ = [
     "LangchainAgentEventType",

{langchain-agentx-python-1.2.6 → langchain-agentx-python-1.2.7}/langchain_agentx/observability/events/subagent_event_mapper.py

@@ -1,7 +1,7 @@
 """
 observability/events/subagent_event_mapper.py — 子 Agent SSE 事件映射
 
-职责：tool_progress / 遗留 subagent_progress → subagent-tool-* 分流；
+职责：tool_progress → subagent-tool-* 分流；
       subagent-start/end 边界 payload 构建。
 链路位置：LangGraphToLangchainAgentEventAdapter._handle_custom_event / _handle_tool_*。
 当前裁剪范围：仅 phase ∈ {tool_use, tool_result}；忽略 model_step / 未知 phase。
@@ -125,29 +125,6 @@ class SubagentProgressEventMapper:
             tool_name=str(data.get("tool_name") or "") or None,
         )
 
-    @classmethod
-    def map_legacy_subagent_progress(
-        cls,
-        data: dict[str, Any],
-    ) -> MappedSubagentProgress | None:
-        """兼容旧 subagent_progress 事件名（runner 已改用 tool_progress）。"""
-        if not isinstance(data, dict):
-            return None
-        legacy_type = data.get("type")
-        if legacy_type not in _SUBAGENT_TOOL_PHASES:
-            return None
-        return cls.map_custom_tool_progress(
-            {
-                "tool_name": data.get("tool_name", ""),
-                "tool_call_id": data.get("parent_tool_use_id", ""),
-                "agent_id": data.get("agent_id", ""),
-                "phase": legacy_type,
-                "step": data.get("step", 0),
-                "summary": data.get("summary", ""),
-                "data": {"subagent_type": data.get("subagent_type", "")},
-            }
-        )
-
 
 __all__ = [
     "MappedSubagentProgress",