agentengine-sdk-python 0.8.3__py3-none-any.whl → 0.8.5__py3-none-any.whl

ksadk/runners/_langgraph_runner_streams.py

@@ -5,7 +5,7 @@
 
 from __future__ import annotations
 
-import inspect
+import logging
 import time
 import uuid
 from typing import TYPE_CHECKING, Any, AsyncIterator, Dict, Mapping
@@ -15,6 +15,10 @@ 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
+
+logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
     pass
@@ -23,6 +27,7 @@ if TYPE_CHECKING:
 class _LangGraphStreamMixin:
     async def stream(self, input_data: Dict[str, Any]) -> AsyncIterator[Dict[str, Any]]:
         """流式调用 LangGraph 图"""
+        await self.prepare_runtime_capabilities()
         payload = dict(input_data)
         payload.pop("_ksadk_force_graph_invoke", None)
         session_id = payload.pop("session_id", None) or str(uuid.uuid4())[:8]
@@ -41,7 +46,10 @@ class _LangGraphStreamMixin:
             payload["input"] = self._gateway_approval_follow_up_input()
             resume_value = payload["input"]
         checkpoint_ref = self._extract_langgraph_checkpoint_ref(payload)
-        native_context = self.build_native_context(payload.get("platform_context"))
+        native_context = self.build_native_context(
+            payload.get("platform_context"),
+            context_schema=getattr(self._agent, "context_schema", None),
+        )
         invoke_payload = dict(payload)
         invoke_payload["session_id"] = session_id
         if history:
@@ -53,12 +61,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:
@@ -66,7 +75,7 @@ class _LangGraphStreamMixin:
         elif is_resume and not is_gateway_approval_resume:
             # Keep the interrupt value intact for ``Command(resume=...)``;
             # prepare-state hooks only shape fresh user turns.
-            state = resume_value
+            state = self._unwrap_resume_value(resume_value)
         elif self._has_prepare_state_hook():
             state = self._prepare_state_with_hook(
                 payload,
@@ -82,6 +91,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]] = {}
@@ -92,6 +103,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],
@@ -164,6 +176,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
 
@@ -191,6 +205,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:
@@ -215,15 +242,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 {
@@ -231,8 +253,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)
@@ -249,6 +270,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"):
@@ -388,11 +414,27 @@ 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 兜底一致。
+                        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 里读不到结构化信息时，退回原始 __interrupt__。
+                            _interrupt_info = output["__interrupt__"]
                         yield {
                             "type": "interrupt",
-                            "interrupt_info": output["__interrupt__"],
+                            "interrupt_info": _interrupt_info,
                             "session_id": session_id,
                         }
                         return
@@ -404,9 +446,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
@@ -414,20 +462,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",
@@ -451,7 +505,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
@@ -460,11 +514,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)
@@ -473,13 +530,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()
@@ -497,6 +556,8 @@ 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)
@@ -531,6 +592,7 @@ class _LangGraphStreamMixin:
             RunInterrupted,
             RunStarted,
             SourceRef,
+            UsageReported,
         )
         from ksadk.events.identity import stable_event_id, stable_item_id, stable_scope_id
         from ksadk.events.reducer import StreamReducer
@@ -553,21 +615,25 @@ class _LangGraphStreamMixin:
         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"))
+        native_context = self.build_native_context(
+            payload.get("platform_context"),
+            context_schema=getattr(self._agent, "context_schema", None),
+        )
 
-        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()),
             )
 
         # --- build state (same logic as stream()) ---
         if is_checkpoint_resume:
             state = resume_value
         elif is_resume:
-            state = resume_value
+            state = self._unwrap_resume_value(resume_value)
         elif self._has_prepare_state_hook():
             state = self._prepare_state_with_hook(payload, session_id, history)
         else:
@@ -668,6 +734,8 @@ class _LangGraphStreamMixin:
         )
         adapter = LangGraphEventAdapter()
         reducer = StreamReducer()
+        accumulated_usage: dict[str, Any] = {}
+        final_result_fields: dict[str, Any] = {}
 
         # --- build stream kwargs (v3 rejects stream_mode/subgraphs) ---
         stream_kwargs: dict[str, Any] = {"version": "v3", "config": config}
@@ -680,6 +748,18 @@ class _LangGraphStreamMixin:
         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, UsageReported):
+                    accumulated_usage = accumulate_usage(
+                        accumulated_usage,
+                        {
+                            "input_tokens": event.input_tokens,
+                            "output_tokens": event.output_tokens,
+                            "total_tokens": event.total_tokens,
+                            "cached_tokens": event.cached_tokens,
+                            "reasoning_tokens": event.reasoning_tokens,
+                        },
+                    )
+                    event = event.model_copy(update=accumulated_usage)
                 if isinstance(event, RunInterrupted):
                     was_interrupted = True
                     # Extract checkpoint from graph state and emit
@@ -687,20 +767,71 @@ class _LangGraphStreamMixin:
                     # consumers (agui agent) can resolve the resumable
                     # checkpoint_id before processing the terminal interrupt.
                     try:
-                        ckpt_state = self._agent.get_state(config)
+                        # 统一异步状态读取入口：managed 模式挂 AsyncPostgresSaver，
+                        # 在事件循环里同步 get_state 会直接报错。
+                        ckpt_state, ckpt_read_error = await self._read_graph_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": "",
+                                # 保留状态自报的真实寻址（子图 ns 带任务路径），
+                                # 根 checkpoint 时为空串。恢复按原地址定位。
+                                "checkpoint_ns": str(
+                                    (ckpt_config.get("configurable") or {}).get(
+                                        "checkpoint_ns", ""
+                                    )
+                                    or ""
+                                ),
                                 "checkpoint_id": ckpt_id,
+                                **({"next_node": ckpt_next_node} if ckpt_next_node else {}),
                             }
                             continuation_id = stable_item_id(
                                 "langgraph",
@@ -729,7 +860,7 @@ class _LangGraphStreamMixin:
                                 source=SourceRef(
                                     framework="langgraph",
                                     native_run_id=run_id,
-                                    metadata={"checkpoint": True},
+                                    metadata=ckpt_source_metadata,
                                 ),
                                 continuation_id=continuation_id,
                                 continuation_kind="graph_checkpoint",
@@ -738,8 +869,15 @@ class _LangGraphStreamMixin:
                             )
                             reducer.apply(cont_event)
                             yield cont_event
-                    except Exception:
-                        pass
+                    except Exception as ckpt_error:
+                        # 恢复指针丢失会让这次 interrupt 无法恢复——绝不能静默：
+                        # RunInterrupted 仍然发出（下游知道 run 已暂停），但必须
+                        # 留下显性告警指向根因。
+                        logger.warning(
+                            "LangGraph resume checkpoint 读取失败，ContinuationCreated "
+                            "未发出（run 可标记为 interrupted 但不可恢复）: %s",
+                            ckpt_error,
+                        )
                     reducer.apply(event)
                     last_timestamp = float(getattr(event, "timestamp", 0.0) or last_timestamp)
                     yield event
@@ -747,6 +885,9 @@ class _LangGraphStreamMixin:
                 reducer.apply(event)
                 last_timestamp = float(getattr(event, "timestamp", 0.0) or last_timestamp)
                 yield event
+            # v3 exposes the final graph state after the event stream completes.
+            final_state = await run_stream.output()
+            final_result_fields = skill_eval_response_fields(final_state)
         except Exception as exc:
             error_source = SourceRef(
                 framework="langgraph",
@@ -796,7 +937,10 @@ class _LangGraphStreamMixin:
         terminal_source = SourceRef(
             framework="langgraph",
             native_run_id=run_id,
-            metadata=dict(source_metadata),
+            metadata={
+                **source_metadata,
+                **({"metrics": final_result_fields} if final_result_fields else {}),
+            },
         )
         yield RunCompleted(
             schema_version=2,

ksadk/runners/_langgraph_state_reader.py

@@ -0,0 +1,106 @@
+"""LangGraph 图状态读取的唯一入口。
+
+审批探测（goal-18）、checkpoint 元数据、usage 提取、可恢复性校验共用同一套
+读取与 interrupt 解析逻辑；除本模块外不得直接调用 ``aget_state``/``get_state``。
+"""
+
+from __future__ import annotations
+
+import inspect
+import logging
+from collections.abc import Mapping
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_MAX_NESTED_DEPTH = 4
+
+
+def graph_state_reader(agent: Any) -> Any | None:
+    """返回该图的 state 读取函数（async 优先），没有则 None。"""
+    return getattr(agent, "aget_state", None) or getattr(agent, "get_state", None)
+
+
+async def read_graph_state(
+    agent: Any,
+    config: Mapping[str, Any],
+    *,
+    include_subgraphs: bool = False,
+) -> tuple[Any | None, Exception | None]:
+    """统一的图状态读取入口。
+
+    返回 ``(state, error)``；读取失败时 ``error`` 非 None。调用方按语义决定后续：
+    usage / metadata / 可恢复性这类旁路读取可以降级；审批判定必须显性失败。
+    任何情况下都不静默吞掉异常——至少留一条 warning 日志。
+
+    ``include_subgraphs=True`` 会把子图状态一并取回，供 interrupt 探测遍历嵌套暂停点。
+    """
+    reader = graph_state_reader(agent)
+    if reader is None:
+        return None, None
+    try:
+        if include_subgraphs:
+            try:
+                state = reader(config, subgraphs=True)
+            except TypeError:
+                # 老版本 graph 不接受 subgraphs 关键字。
+                state = reader(config)
+        else:
+            state = reader(config)
+        if inspect.isawaitable(state):
+            state = await state
+    except Exception as exc:
+        logger.warning("LangGraph state read failed: %r", exc)
+        return None, exc
+    return state, None
+
+
+def interrupt_info_from_state(state: Any, *, _depth: int = 0) -> dict:
+    """从 state 中获取 interrupt 信息（含子图嵌套任务）"""
+    if state is None or _depth > _MAX_NESTED_DEPTH:
+        return {}
+    tasks = getattr(state, "tasks", None)
+    for task in tasks or ():
+        interrupts = getattr(task, "interrupts", None)
+        for intr in interrupts or ():
+            if hasattr(intr, "value"):
+                return _interrupt_info_from_value(intr)
+        # subgraphs=True 时子图快照挂在 task.state 上，递归下钻。
+        nested = getattr(task, "state", None)
+        if nested is not None:
+            info = interrupt_info_from_state(nested, _depth=_depth + 1)
+            if info:
+                return info
+    return {}
+
+
+def _interrupt_info_from_value(intr: Any) -> dict:
+    value = intr.value
+    info = dict(value) if isinstance(value, Mapping) else {"value": value}
+    interrupt_id = str(getattr(intr, "id", "") or "")
+    if interrupt_id:
+        info.setdefault("approval_request_id", interrupt_id)
+    # HumanInTheLoopMiddleware 的 interrupt value 把 tool_name/arguments 嵌在
+    # action_requests[0] 里；下游期望顶层字段，这里提取并保留原 action_requests。
+    action_requests = info.get("action_requests")
+    if isinstance(action_requests, list) and action_requests:
+        first = action_requests[0]
+        if isinstance(first, Mapping):
+            info.setdefault("tool_name", str(first.get("name") or ""))
+            raw_args = first.get("args") or first.get("arguments")
+            if raw_args is not None:
+                info.setdefault("arguments", raw_args)
+            if first.get("description") is not None:
+                info.setdefault("description", str(first.get("description")))
+    return info
+
+
+def known_subgraph_namespaces(agent: Any) -> set[str]:
+    """当前图里真实存在的子图 namespace 集合（无法探测时返回空集）。"""
+    get_subgraphs = getattr(agent, "get_subgraphs", None)
+    if not callable(get_subgraphs):
+        return set()
+    try:
+        return {str(ns) for ns, _ in get_subgraphs()}
+    except Exception:
+        return set()