agentengine-sdk-python 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

ksadk/runners/_langgraph_runner_streams.py

@@ -5,22 +5,31 @@
 
 from __future__ import annotations
 
-import inspect
+import logging
 import time
 import uuid
 from typing import TYPE_CHECKING, Any, AsyncIterator, Dict, Mapping
 
+from langgraph.stream import ProtocolEvent, StreamTransformer
 from langgraph.types import Command
 
 from ksadk.conversations.reasoning_markup import ReasoningMarkupParser, strip_reasoning_markup
 from ksadk.events.runtime_event import RuntimeEvent
 from ksadk.runners.usage_accumulator import accumulate_usage
+from ksadk.runtime.skill_eval_result import skill_eval_response_fields
+from ksadk.runtime.timing import extract_timing
+
+from ksadk.runners._langgraph_canonical_streams import _LangGraphCanonicalStreamMixin
+
+from ksadk.runners._langgraph_tools_transformer import _CanonicalToolsTransformer
+
+logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
     pass
 
 
-class _LangGraphStreamMixin:
+class _LangGraphStreamMixin(_LangGraphCanonicalStreamMixin):
     async def stream(self, input_data: Dict[str, Any]) -> AsyncIterator[Dict[str, Any]]:
         """流式调用 LangGraph 图"""
         await self.prepare_runtime_capabilities()
@@ -57,12 +66,13 @@ class _LangGraphStreamMixin:
             invoke_payload["resume_payload_provided"] = resume_payload_provided
             invoke_payload["resume_interrupt_id"] = resume_interrupt_id
 
-        config = self._get_config(session_id)
+        config = await self._get_session_config(session_id)
         if is_checkpoint_resume:
             config = self._apply_checkpoint_resume_config(
                 config,
                 session_id=session_id,
                 checkpoint_ref=checkpoint_ref,
+                enforce_bound_thread=bool(self._invocation_identity_scope_ref()),
             )
 
         if is_checkpoint_resume:
@@ -86,6 +96,8 @@ class _LangGraphStreamMixin:
         inline_reasoning_parser = ReasoningMarkupParser()
         emitted_non_text_event = False
         final_output_text = ""
+        final_output_timing: dict[str, Any] = {}
+        final_result_fields: dict[str, Any] = {}
         final_output_usage: dict[str, Any] = {}
         final_output_last_usage: dict[str, Any] = {}
         model_run_usages: dict[str, dict[str, Any]] = {}
@@ -96,6 +108,7 @@ class _LangGraphStreamMixin:
         model_step_indexes: dict[str, int] = {}
         first_token_seen: set[str] = set()
         next_step_index = 0
+        internal_model_runs: set[str] = set()
 
         def model_run_key(
             event: Mapping[str, Any],
@@ -168,6 +181,8 @@ class _LangGraphStreamMixin:
             last_usage = self._extract_last_usage(result)
             if last_usage:
                 final_chunk.setdefault("metadata", {})["last_usage"] = last_usage
+            if timing := extract_timing(result):
+                final_chunk["timing"] = timing
             yield final_chunk
             return
 
@@ -195,6 +210,19 @@ class _LangGraphStreamMixin:
             async for event in self._agent.astream_events(stream_input, **stream_kwargs):
                 event_kind = event.get("event", "")
 
+                # This metadata is scoped to a model call, not the whole graph.
+                # Remember it because subsequent chunks may omit metadata.
+                event_run_id = str(event.get("run_id") or "")
+                event_metadata = event.get("metadata") or {}
+                internal_output = (
+                    isinstance(event_metadata, Mapping)
+                    and event_metadata.get("ksadk_output_visibility") == "internal"
+                )
+                if event_kind.startswith("on_chat_model_"):
+                    if internal_output and event_run_id:
+                        internal_model_runs.add(event_run_id)
+                    internal_output = internal_output or event_run_id in internal_model_runs
+
                 if event_kind == "on_chat_model_start":
                     model_call_id = str(event.get("run_id") or "")
                     if model_call_id:
@@ -219,15 +247,10 @@ class _LangGraphStreamMixin:
                     if not chunk:
                         continue
                     model_call_id = str(event.get("run_id") or "")
-                    if (
-                        model_call_id in model_started_at
-                        and model_call_id not in first_token_seen
-                    ):
+                    if model_call_id in model_started_at and model_call_id not in first_token_seen:
                         reasoning_content = getattr(chunk, "reasoning_content", None)
                         if not reasoning_content and hasattr(chunk, "additional_kwargs"):
-                            reasoning_content = chunk.additional_kwargs.get(
-                                "reasoning_content"
-                            )
+                            reasoning_content = chunk.additional_kwargs.get("reasoning_content")
                         if getattr(chunk, "content", None) or reasoning_content:
                             first_token_seen.add(model_call_id)
                             yield {
@@ -235,8 +258,7 @@ class _LangGraphStreamMixin:
                                 "step_id": f"step_{model_call_id}",
                                 "model_call_id": model_call_id,
                                 "ttft_ms": int(
-                                    (time.monotonic() - model_started_at[model_call_id])
-                                    * 1000
+                                    (time.monotonic() - model_started_at[model_call_id]) * 1000
                                 ),
                             }
                     chunk_usage = self._extract_usage(chunk)
@@ -253,6 +275,11 @@ class _LangGraphStreamMixin:
                             stream_usage_run_keys.add(run_key)
                             record_model_usage(event, latest_stream_usage)
 
+                    # Collect usage/lifecycle above even for internal calls, but
+                    # never feed their text into the shared reasoning parser.
+                    if internal_output:
+                        continue
+
                     # 推理内容
                     reasoning = getattr(chunk, "reasoning_content", None)
                     if not reasoning and hasattr(chunk, "additional_kwargs"):
@@ -392,26 +419,23 @@ class _LangGraphStreamMixin:
 
                 elif event_kind == "on_chain_end":
                     output = event.get("data", {}).get("output", {})
+                    if not event.get("parent_ids"):
+                        final_output_timing = extract_timing(output)
+                        final_result_fields = skill_eval_response_fields(output)
                     if isinstance(output, dict) and "__interrupt__" in output:
                         emitted_non_text_event = True
                         # __interrupt__ 是 LangGraph 原始 Interrupt 对象列表，
                         # 直接 yield 会导致下游拿不到 tool_name/description（非 Mapping）。
                         # 用 _get_interrupt_info 从 state 提取结构化 interrupt_info，
                         # 与 406-412 的异常路径和 419-436 的 pending_approval 兜底一致。
-                        _interrupt_info = {}
-                        try:
-                            _get_state = getattr(self._agent, "aget_state", None) or getattr(
-                                self._agent, "get_state", None
-                            )
-                            if _get_state is not None:
-                                _maybe_state = _get_state(config)
-                                if inspect.isawaitable(_maybe_state):
-                                    _maybe_state = await _maybe_state
-                                _interrupt_info = self._get_interrupt_info(_maybe_state)
-                        except Exception:
-                            _interrupt_info = {}
+                        state, _error = await self._read_graph_state(
+                            config, include_subgraphs=True
+                        )
+                        _interrupt_info = (
+                            self._get_interrupt_info(state) if state is not None else {}
+                        )
                         if not _interrupt_info:
-                            # 取不到 state 时 fallback 到原始 __interrupt__（兼容旧行为）。
+                            # state 里读不到结构化信息时，退回原始 __interrupt__。
                             _interrupt_info = output["__interrupt__"]
                         yield {
                             "type": "interrupt",
@@ -427,9 +451,15 @@ class _LangGraphStreamMixin:
 
         except Exception as e:
             if "Interrupt" in type(e).__name__:
+                state, error = await self._read_graph_state(config, include_subgraphs=True)
+                if state is None:
+                    # 图已经抛出 interrupt 但状态读不回来：显性失败，不返回空信息。
+                    raise RuntimeError(
+                        "graph interrupted but its checkpoint state could not be read"
+                    ) from error
                 yield {
                     "type": "interrupt",
-                    "interrupt_info": self._get_interrupt_info(self._agent.get_state(config)),
+                    "interrupt_info": self._get_interrupt_info(state),
                     "session_id": session_id,
                 }
                 return
@@ -437,20 +467,26 @@ class _LangGraphStreamMixin:
 
         # goal-18(ksadk-web 人机交互):图因审批门(HITL)在流式中静默暂停时,
         # 这里把审批详情(action_requests)作为 approval 事件冒出,供 UI 渲染审批卡。
-        # 此前流式路径只在 checkpoint 标 resumable,UI 拿不到"该批哪个工具/什么参数/允许哪些决定"。
-        # 注:get_state 在部分 agent 上是 async,统一按 awaitable 处理;取不到则跳过,不破坏事件流。
+        # 失败语义(0.8.5 契约):interrupt 依赖 checkpointer——
+        # - 配了 checkpointer 的图(含内存版),状态读不出来必须显性失败——绝不能把
+        #   "读不到"当成"没有待审批"继续走 completed(审批卡会无声消失)。
+        # - 没配 checkpointer 的图不可能有 interrupt,读不到属于正常情况。
         pending_approval = None
-        try:
-            _get_state = getattr(self._agent, "aget_state", None) or getattr(
-                self._agent, "get_state", None
+        state, error = await self._read_graph_state(config, include_subgraphs=True)
+        if state is None:
+            agent = getattr(self, "_agent", None)
+            has_checkpointer = (
+                getattr(agent, "checkpointer", None) is not None
+                or getattr(agent, "_checkpointer", None) is not None
             )
-            if _get_state is not None:
-                _maybe_state = _get_state(config)
-                if inspect.isawaitable(_maybe_state):
-                    _maybe_state = await _maybe_state
-                pending_approval = self._get_interrupt_info(_maybe_state)
-        except Exception:
-            pending_approval = None
+            if has_checkpointer:
+                raise RuntimeError(
+                    "stream ended without a terminal event and the checkpoint "
+                    "state could not be read; refusing to report the run as completed"
+                ) from error
+            logger.debug("graph has no checkpointer; skipping pending-approval probe")
+        else:
+            pending_approval = self._get_interrupt_info(state)
         if pending_approval:
             yield {
                 "type": "approval",
@@ -474,7 +510,7 @@ class _LangGraphStreamMixin:
 
         if not accumulated_text:
             if final_output_text:
-                final_chunk = {"output": final_output_text, "type": "final"}
+                final_chunk = {"output": final_output_text, "type": "final", **final_result_fields}
                 usage = accumulated_model_usage() or final_output_usage or latest_stream_usage
                 last_usage = (
                     latest_model_usage() or final_output_last_usage or latest_stream_usage or usage
@@ -483,11 +519,14 @@ class _LangGraphStreamMixin:
                     final_chunk["usage"] = usage
                 if last_usage:
                     final_chunk.setdefault("metadata", {})["last_usage"] = last_usage
+                if final_output_timing:
+                    final_chunk["timing"] = final_output_timing
                 yield final_chunk
             elif not emitted_non_text_event:
                 result = await self.invoke({**invoke_payload, "_ksadk_force_graph_invoke": True})
                 fallback_chunk: dict[str, Any] = {
                     "output": result.get("output", ""),
+                    **skill_eval_response_fields(result),
                     "type": "final",
                 }
                 usage = self._extract_usage(result)
@@ -496,13 +535,15 @@ class _LangGraphStreamMixin:
                 last_usage = self._extract_last_usage(result)
                 if last_usage:
                     fallback_chunk.setdefault("metadata", {})["last_usage"] = last_usage
+                if timing := extract_timing(result):
+                    fallback_chunk["timing"] = timing
                 yield fallback_chunk
                 checkpoint_metadata = result.get("metadata") if isinstance(result, dict) else None
                 if isinstance(checkpoint_metadata, dict) and checkpoint_metadata.get("agentengine"):
                     yield {"type": "checkpoint", "metadata": checkpoint_metadata}
                     return
         else:
-            final_chunk = {"output": accumulated_text, "type": "final"}
+            final_chunk = {"output": accumulated_text, "type": "final", **final_result_fields}
             state_usage = await self._latest_state_usage(config)
             usage = (
                 accumulated_model_usage()
@@ -520,371 +561,12 @@ class _LangGraphStreamMixin:
                     or usage
                 )
                 final_chunk.setdefault("metadata", {})["last_usage"] = last_usage
+            if final_output_timing:
+                final_chunk["timing"] = final_output_timing
             yield final_chunk
 
         metadata = await self._latest_checkpoint_metadata(config)
         if metadata:
             yield {"type": "checkpoint", "metadata": metadata}
 
-    async def stream_canonical_events(
-        self, input_data: Dict[str, Any]
-    ) -> AsyncIterator[RuntimeEvent]:
-        """Emit canonical RuntimeEvent (schema_version=2) for a LangGraph run.
-
-        Emits RunStarted/RunCompleted/RunFailed lifecycle events and uses
-        LangGraphEventAdapter to map item.* events from the v3
-        AsyncGraphRunStream.  The old ``stream`` method (dict path) is
-        retained for backward compatibility; runner_adapter prefers this
-        canonical path when present.
-        """
-
-        import time as _time
-
-        from ksadk.events.adapters.langgraph import (
-            LangGraphAdapterContext,
-            LangGraphEventAdapter,
-            LangGraphMappingError,
-        )
-        from ksadk.events.canonical import (
-            ContinuationCreated,
-            ErrorInfo,
-            OutputRef,
-            RunCompleted,
-            RunFailed,
-            RunInterrupted,
-            RunStarted,
-            SourceRef,
-        )
-        from ksadk.events.identity import stable_event_id, stable_item_id, stable_scope_id
-        from ksadk.events.reducer import StreamReducer
-
-        # --- parse input (mirrors stream()) ---
-        payload = dict(input_data)
-        run_id = str(
-            payload.pop("run_id", None) or payload.pop("invocation_id", None) or ""
-        ).strip()
-        if not run_id:
-            raise ValueError(
-                "LangGraph canonical stream requires an explicit run_id or invocation_id"
-            )
-        payload.pop("_ksadk_force_graph_invoke", None)
-        session_id = payload.pop("session_id", None) or str(uuid.uuid4())[:8]
-        history = payload.pop("history", [])
-        is_resume = payload.pop("resume", False)
-        is_checkpoint_resume = bool(payload.pop("checkpoint_resume", False))
-        resume_payload_provided = bool(payload.pop("resume_payload_provided", False))
-        resume_interrupt_id = str(payload.pop("resume_interrupt_id", "") or "")
-        resume_value = payload.get("input")
-        checkpoint_ref = self._extract_langgraph_checkpoint_ref(payload)
-        native_context = self.build_native_context(
-            payload.get("platform_context"),
-            context_schema=getattr(self._agent, "context_schema", None),
-        )
-
-        config = self._get_config(session_id)
-        if is_checkpoint_resume:
-            config = self._apply_checkpoint_resume_config(
-                config,
-                session_id=session_id,
-                checkpoint_ref=checkpoint_ref,
-            )
-
-        # --- build state (same logic as stream()) ---
-        if is_checkpoint_resume:
-            state = resume_value
-        elif is_resume:
-            state = self._unwrap_resume_value(resume_value)
-        elif self._has_prepare_state_hook():
-            state = self._prepare_state_with_hook(payload, session_id, history)
-        else:
-            state = self._to_state(payload, history)
-
-        stream_input = (
-            self._checkpoint_resume_input(
-                state,
-                payload_provided=resume_payload_provided,
-                interrupt_id=resume_interrupt_id,
-            )
-            if is_checkpoint_resume
-            else (Command(resume=state) if is_resume else state)
-        )
-
-        # --- identity ---
-        run_scope_id = stable_scope_id("langgraph", run_id, "$run")
-        run_item_id = stable_item_id("langgraph", run_id, "$run")
-
-        source_metadata: dict[str, Any] = {}
-        if session_id:
-            source_metadata["session_id"] = session_id
-        invocation_id = str(input_data.get("invocation_id") or "").strip()
-        if invocation_id:
-            source_metadata["invocation_id"] = invocation_id
-        agent_id = str(input_data.get("agent_id") or "").strip()
-        if agent_id:
-            source_metadata["agent_id"] = agent_id
-        user_id = str(input_data.get("user_id") or "").strip()
-        if user_id:
-            source_metadata["user_id"] = user_id
-
-        run_source = SourceRef(
-            framework="langgraph",
-            native_run_id=run_id,
-            metadata=source_metadata,
-        )
-
-        started_at = _time.time()
-        yield RunStarted(
-            schema_version=2,
-            event_id=stable_event_id(
-                "langgraph",
-                run_scope_id,
-                run_item_id,
-                "run.started",
-                "run",
-                run_id,
-                0,
-            ),
-            seq=0,
-            timestamp=started_at,
-            run_id=run_id,
-            scope_id=run_scope_id,
-            source=run_source,
-            status="running",
-        )
-
-        # --- check astream_events availability ---
-        if not hasattr(self._agent, "astream_events"):
-            terminal_source = SourceRef(
-                framework="langgraph",
-                native_run_id=run_id,
-                metadata={**source_metadata, "fallback": "no_astream_events"},
-            )
-            yield RunCompleted(
-                schema_version=2,
-                event_id=stable_event_id(
-                    "langgraph",
-                    run_scope_id,
-                    run_item_id,
-                    "run.completed",
-                    "run",
-                    run_id,
-                    0,
-                ),
-                seq=1,
-                timestamp=_time.time(),
-                run_id=run_id,
-                scope_id=run_scope_id,
-                source=terminal_source,
-                status="completed",
-                output_refs=(),
-            )
-            return
-
-        # --- build adapter context ---
-        adapter_checkpoint_ref: dict[str, Any] | None = None
-        if checkpoint_ref:
-            adapter_checkpoint_ref = dict(checkpoint_ref)
-            adapter_checkpoint_ref.setdefault("checkpoint_ns", "")
-
-        adapter_context = LangGraphAdapterContext(
-            run_id=run_id,
-            graph_run_id=run_id,
-            initial_seq=1,
-            checkpoint_ref=adapter_checkpoint_ref,
-        )
-        adapter = LangGraphEventAdapter()
-        reducer = StreamReducer()
-
-        # --- build stream kwargs (v3 rejects stream_mode/subgraphs) ---
-        stream_kwargs: dict[str, Any] = {"version": "v3", "config": config}
-        if native_context and self._callable_accepts_keyword(self._agent.astream_events, "context"):
-            stream_kwargs["context"] = native_context
-
-        was_interrupted = False
-        last_timestamp = started_at
-
-        try:
-            run_stream = await self._agent.astream_events(stream_input, **stream_kwargs)
-            async for event in adapter.stream_run(run_stream, adapter_context):
-                if isinstance(event, RunInterrupted):
-                    was_interrupted = True
-                    # Extract checkpoint from graph state and emit
-                    # ContinuationCreated BEFORE RunInterrupted so downstream
-                    # consumers (agui agent) can resolve the resumable
-                    # checkpoint_id before processing the terminal interrupt.
-                    try:
-                        ckpt_state = self._agent.get_state(config)
-                        ckpt_config = getattr(ckpt_state, "config", {}) or {}
-                        ckpt_id = str(
-                            (ckpt_config.get("configurable") or {}).get("checkpoint_id", "") or ""
-                        )
-                        if ckpt_id:
-                            # Extract next_node from graph state so the
-                            # projection layer can surface it in the REST
-                            # checkpoint payload.
-                            next_nodes_raw = (
-                                ckpt_state.get("next")
-                                if isinstance(ckpt_state, dict)
-                                else getattr(ckpt_state, "next", None)
-                            )
-                            ckpt_next_node = ""
-                            if isinstance(next_nodes_raw, str):
-                                ckpt_next_node = next_nodes_raw.strip()
-                            elif isinstance(next_nodes_raw, (list, tuple, set)):
-                                ckpt_next_node = str(next(iter(next_nodes_raw)) or "").strip()
-                            # Enrich source metadata with checkpoint
-                            # capability (backend/scope/durable) so the
-                            # projection layer does not fall back to unknown.
-                            ckpt_capability = self.describe_checkpoint_capability()
-                            ckpt_source_metadata: dict[str, Any] = {"checkpoint": True}
-                            if isinstance(ckpt_capability, dict):
-                                ckpt_is_terminal = not bool(ckpt_next_node)
-                                ckpt_is_resumable = bool(
-                                    ckpt_capability.get("Supported")
-                                    and ckpt_next_node
-                                    and ckpt_capability.get("Scope") != "process_local"
-                                )
-                                ckpt_source_metadata["capability"] = {
-                                    "backend": str(ckpt_capability.get("Backend") or "unknown"),
-                                    "scope": str(ckpt_capability.get("Scope") or "unknown"),
-                                    "durable": bool(ckpt_capability.get("Durable", False)),
-                                    "is_terminal": ckpt_is_terminal,
-                                    "is_resumable": ckpt_is_resumable,
-                                    "resume_status": (
-                                        "resumable" if ckpt_is_resumable else "disabled"
-                                    ),
-                                    "resume_disabled_reason": (
-                                        "该 checkpoint 已是终态；可选择更早恢复点重跑"
-                                        if ckpt_is_terminal
-                                        else str(ckpt_capability.get("Reason") or "")
-                                    ),
-                                    **({"next_node": ckpt_next_node} if ckpt_next_node else {}),
-                                }
-                            ckpt_ref = {
-                                "thread_id": str(
-                                    (ckpt_config.get("configurable") or {}).get(
-                                        "thread_id", session_id
-                                    )
-                                ),
-                                "checkpoint_ns": "",
-                                "checkpoint_id": ckpt_id,
-                                **({"next_node": ckpt_next_node} if ckpt_next_node else {}),
-                            }
-                            continuation_id = stable_item_id(
-                                "langgraph",
-                                run_scope_id,
-                                "continuation",
-                                "graph-checkpoint",
-                                ckpt_ref["thread_id"],
-                                "checkpoint-ns:",
-                                ckpt_id,
-                            )
-                            cont_event = ContinuationCreated(
-                                schema_version=2,
-                                event_id=stable_event_id(
-                                    "langgraph",
-                                    run_scope_id,
-                                    continuation_id,
-                                    "continuation.created",
-                                    "checkpoint",
-                                    run_id,
-                                    0,
-                                ),
-                                seq=adapter_context.allocate_placeholder_seq(),
-                                timestamp=last_timestamp,
-                                run_id=run_id,
-                                scope_id=run_scope_id,
-                                source=SourceRef(
-                                    framework="langgraph",
-                                    native_run_id=run_id,
-                                    metadata=ckpt_source_metadata,
-                                ),
-                                continuation_id=continuation_id,
-                                continuation_kind="graph_checkpoint",
-                                resumable=True,
-                                ref=ckpt_ref,
-                            )
-                            reducer.apply(cont_event)
-                            yield cont_event
-                    except Exception:
-                        pass
-                    reducer.apply(event)
-                    last_timestamp = float(getattr(event, "timestamp", 0.0) or last_timestamp)
-                    yield event
-                    return
-                reducer.apply(event)
-                last_timestamp = float(getattr(event, "timestamp", 0.0) or last_timestamp)
-                yield event
-        except Exception as exc:
-            error_source = SourceRef(
-                framework="langgraph",
-                native_run_id=run_id,
-                metadata={"error_type": type(exc).__name__},
-            )
-            error_code = exc.code if isinstance(exc, LangGraphMappingError) else "langgraph_failed"
-            yield RunFailed(
-                schema_version=2,
-                event_id=stable_event_id(
-                    "langgraph",
-                    run_scope_id,
-                    run_item_id,
-                    "run.failed",
-                    "run",
-                    run_id,
-                    0,
-                ),
-                seq=adapter_context.allocate_placeholder_seq(),
-                timestamp=_time.time(),
-                run_id=run_id,
-                scope_id=run_scope_id,
-                source=error_source,
-                status="failed",
-                error=ErrorInfo(
-                    code=error_code,
-                    message=str(exc) or type(exc).__name__,
-                    source="langgraph",
-                    scope_id=run_scope_id,
-                ),
-            )
-            return
-
-        # --- emit RunCompleted (skip if RunInterrupted was terminal) ---
-        if was_interrupted:
-            return
-
-        projection = reducer.snapshot()
-        output_refs = tuple(
-            OutputRef(scope_id=item.scope_id, item_id=item.item_id)
-            for item in projection.items
-            if item.status == "completed"
-            and item.item_kind == "message"
-            and item.phase == "final_answer"
-        )
-
-        terminal_source = SourceRef(
-            framework="langgraph",
-            native_run_id=run_id,
-            metadata=dict(source_metadata),
-        )
-        yield RunCompleted(
-            schema_version=2,
-            event_id=stable_event_id(
-                "langgraph",
-                run_scope_id,
-                run_item_id,
-                "run.completed",
-                "run",
-                run_id,
-                0,
-            ),
-            seq=adapter_context.allocate_placeholder_seq(),
-            timestamp=last_timestamp,
-            run_id=run_id,
-            scope_id=run_scope_id,
-            source=terminal_source,
-            status="completed",
-            output_refs=output_refs,
-        )
-
-
 __all__ = ["_LangGraphStreamMixin"]