fix: improve graph schema detection (#576)

Author: cristipufu

pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "uipath-langchain"
-version = "0.5.58"
+version = "0.5.59"
 description = "Python SDK that enables developers to build and deploy LangGraph agents to the UiPath Cloud Platform"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"
 dependencies = [
-    "uipath>=2.8.23,<2.9.0",
-    "uipath-runtime>=0.8.0, <0.9.0",
+    "uipath>=2.8.27, <2.9.0",
+    "uipath-runtime>=0.8.2, <0.9.0",
     "langgraph>=1.0.0, <2.0.0",
     "langchain-core>=1.2.11, <2.0.0",
     "langgraph-checkpoint-sqlite>=3.0.3, <4.0.0",

src/uipath_langchain/runtime/runtime.py

@@ -134,7 +134,7 @@ async def stream(
                 stream_mode=["messages", "updates"],
                 subgraphs=True,
             ):
-                _, chunk_type, data = stream_chunk
+                namespace, chunk_type, data = stream_chunk
 
                 # Emit UiPathRuntimeMessageEvent for messages
                 if chunk_type == "messages":
@@ -172,6 +172,10 @@ async def stream(
                                 if isinstance(agent_data, dict)
                                 else {},
                                 node_name=node_name,
+                                qualified_node_name=self._build_node_name(
+                                    namespace,
+                                    node_name,
+                                ),
                             )
                             yield state_event
 
@@ -454,6 +458,47 @@ def _is_middleware_node(self, node_name: str) -> bool:
         """Check if a node name represents a middleware node."""
         return node_name in self._middleware_node_names
 
+    def _build_node_name(self, namespace: Any, node_name: str) -> str:
+        """Build a fully qualified node name with subgraph prefix from the namespace.
+
+        When streaming with ``subgraphs=True``, LangGraph provides a namespace
+        tuple that identifies the subgraph hierarchy a node belongs to. This
+        method extracts the subgraph names and prepends them to the node name.
+
+        Args:
+            namespace: A tuple representing the subgraph hierarchy.
+                - () for the root graph.
+                - ("subgraph_name:node_id",) for a single-level subgraph.
+                - ("subgraph_name:node_id", "nested:node_id") for nested subgraphs.
+            node_name: The name of the node within its graph.
+
+        Returns:
+            The fully qualified node name. For example:
+                - "agent" when called from the root graph.
+                - "coder:generate" when called from the *coder* subgraph.
+                - "coder:debugger:analyze" when called from *debugger* nested inside *coder*.
+        """
+        if not namespace:
+            return node_name
+        if not isinstance(namespace, (tuple, list)):
+            return node_name
+        parts = []
+        for ns in namespace:
+            if not isinstance(ns, str):
+                continue
+            if not ns:
+                continue
+            # Extract subgraph name (part before ':'), fall back to full string
+            part = ns.split(":")[0] if ":" in ns else ns
+            if part:
+                parts.append(part)
+
+        if not parts:
+            return node_name
+
+        prefix = ":".join(parts)
+        return f"{prefix}:{node_name}"
+
     async def dispose(self) -> None:
         """Cleanup runtime resources."""
         pass

src/uipath_langchain/runtime/schema.py

@@ -26,6 +26,24 @@
 
 T = TypeVar("T")
 
+# Known attribute names on LangChain/LangGraph runnables that typically
+# hold nested Runnable instances.  Scanning only these avoids the cost of
+# iterating over *every* attribute returned by vars().
+_KNOWN_RUNNABLE_ATTRS = (
+    "bound",
+    "first",
+    "middle",
+    "last",
+    "steps",
+    "runnable",
+    "default",
+    "fallbacks",
+    "branches",
+)
+
+# Attribute names used to find the wrapped function inside runnables.
+_FUNC_ATTR_NAMES = ("func", "_func", "afunc", "_afunc")
+
 
 @dataclass
 class SchemaDetails:
@@ -66,7 +84,7 @@ def _unwrap_runnable_callable(
 
     # 2) Generic LangChain function-wrapping runnables
     if func is None:
-        for attr_name in ("func", "_func", "afunc", "_afunc"):
+        for attr_name in _FUNC_ATTR_NAMES:
             maybe = getattr(runnable, attr_name, None)
             if callable(maybe):
                 func = maybe
@@ -84,116 +102,108 @@ def _unwrap_runnable_callable(
                 if found is not None:
                     return found
 
-    # 4) Deep-scan attributes, including nested runnables / containers
-    def _scan_value(value: Any) -> T | None:
-        if isinstance(value, target_type):
-            return value
-        if isinstance(value, Runnable):
-            return _unwrap_runnable_callable(value, target_type, _seen)
-        if isinstance(value, dict):
-            for v in value.values():
-                found = _scan_value(v)
-                if found is not None:
-                    return found
-        # Handle lists, tuples, sets, etc. but avoid strings/bytes
-        if isinstance(value, Iterable) and not isinstance(value, (str, bytes)):
-            for item in value:
-                found = _scan_value(item)
-                if found is not None:
-                    return found
-        return None
-
-    try:
-        attrs = vars(runnable)
-    except TypeError:
-        attrs = {}
-
-    for value in attrs.values():
-        found = _scan_value(value)
+    # 4) Scan only known runnable-holding attributes instead of all vars()
+    for attr_name in _KNOWN_RUNNABLE_ATTRS:
+        value = getattr(runnable, attr_name, None)
+        if value is None:
+            continue
+        found = _scan_value(value, target_type, _seen)
         if found is not None:
             return found
 
     return None
 
 
-def _get_node_type(node: Node) -> str:
-    """Determine the type of a LangGraph node using strongly-typed isinstance checks.
+def _scan_value(
+    value: Any,
+    target_type: type[T],
+    _seen: set[int],
+) -> T | None:
+    """Recursively scan a value for an instance of target_type."""
+    if isinstance(value, target_type):
+        return value
+    if isinstance(value, Runnable):
+        return _unwrap_runnable_callable(value, target_type, _seen)
+    if isinstance(value, dict):
+        for v in value.values():
+            found = _scan_value(v, target_type, _seen)
+            if found is not None:
+                return found
+    # Handle lists, tuples, sets, etc. but avoid strings/bytes
+    elif isinstance(value, Iterable) and not isinstance(value, (str, bytes)):
+        for item in value:
+            found = _scan_value(item, target_type, _seen)
+            if found is not None:
+                return found
+    return None
+
+
+def _extract_model_metadata(model: BaseLanguageModel[Any]) -> dict[str, Any]:
+    """Extract metadata from a language model instance.
 
     Args:
-        node: A Node object from the graph
+        model: A language model instance
 
     Returns:
-        String representing the node type
+        Dictionary containing model metadata
     """
-    if node.id in ("__start__", "__end__"):
-        return node.id
+    metadata: dict[str, Any] = {}
 
-    if node.data is None:
-        return "node"
+    if hasattr(model, "model") and isinstance(model.model, str):
+        metadata["model_name"] = model.model
+    elif hasattr(model, "model_name") and model.model_name:
+        metadata["model_name"] = model.model_name
 
-    if not isinstance(node.data, Runnable):
-        return "node"
+    if hasattr(model, "temperature") and model.temperature is not None:
+        metadata["temperature"] = model.temperature
 
-    tool_node = _unwrap_runnable_callable(node.data, ToolNode)
-    if tool_node is not None:
-        return "tool"
-
-    chat_model = _unwrap_runnable_callable(node.data, BaseChatModel)  # type: ignore[type-abstract]
-    if chat_model is not None:
-        return "model"
-
-    language_model = _unwrap_runnable_callable(node.data, BaseLanguageModel)  # type: ignore[type-abstract]
-    if language_model is not None:
-        return "model"
+    if hasattr(model, "max_tokens") and model.max_tokens is not None:
+        metadata["max_tokens"] = model.max_tokens
+    elif (
+        hasattr(model, "max_completion_tokens")
+        and model.max_completion_tokens is not None
+    ):
+        metadata["max_tokens"] = model.max_completion_tokens
 
-    return "node"
+    return metadata
 
 
-def _get_node_metadata(node: Node) -> dict[str, Any]:
-    """Extract metadata from a node in a type-safe manner.
+def _get_node_info(node: Node) -> tuple[str, dict[str, Any]]:
+    """Determine the type and metadata of a LangGraph node in a single pass.
 
     Args:
         node: A Node object from the graph
 
     Returns:
-        Dictionary containing node metadata
+        Tuple of (node_type string, metadata dict)
     """
-    if node.data is None:
-        return {}
-
-    # Early return if data is not a Runnable
-    if not isinstance(node.data, Runnable):
-        return {}
+    if node.id in ("__start__", "__end__"):
+        return node.id, {}
 
-    metadata: dict[str, Any] = {}
+    if node.data is None or not isinstance(node.data, Runnable):
+        return "node", {}
 
+    # Check for ToolNode
     tool_node = _unwrap_runnable_callable(node.data, ToolNode)
     if tool_node is not None:
+        metadata: dict[str, Any] = {}
         if hasattr(tool_node, "_tools_by_name"):
             tools_by_name = tool_node._tools_by_name
             metadata["tool_names"] = list(tools_by_name.keys())
             metadata["tool_count"] = len(tools_by_name)
-        return metadata
+        return "tool", metadata
 
+    # Check for ChatModel (subclass of BaseLanguageModel, check first)
     chat_model = _unwrap_runnable_callable(node.data, BaseChatModel)  # type: ignore[type-abstract]
     if chat_model is not None:
-        if hasattr(chat_model, "model") and isinstance(chat_model.model, str):
-            metadata["model_name"] = chat_model.model
-        elif hasattr(chat_model, "model_name") and chat_model.model_name:
-            metadata["model_name"] = chat_model.model_name
-
-        if hasattr(chat_model, "temperature") and chat_model.temperature is not None:
-            metadata["temperature"] = chat_model.temperature
-
-        if hasattr(chat_model, "max_tokens") and chat_model.max_tokens is not None:
-            metadata["max_tokens"] = chat_model.max_tokens
-        elif (
-            hasattr(chat_model, "max_completion_tokens")
-            and chat_model.max_completion_tokens is not None
-        ):
-            metadata["max_tokens"] = chat_model.max_completion_tokens
+        return "model", _extract_model_metadata(chat_model)
 
-    return metadata
+    # Check for other language models
+    language_model = _unwrap_runnable_callable(node.data, BaseLanguageModel)  # type: ignore[type-abstract]
+    if language_model is not None:
+        return "model", _extract_model_metadata(language_model)
+
+    return "node", {}
 
 
 def _convert_graph_to_uipath(graph: Graph) -> UiPathRuntimeGraph:
@@ -207,12 +217,13 @@ def _convert_graph_to_uipath(graph: Graph) -> UiPathRuntimeGraph:
     """
     nodes: list[UiPathRuntimeNode] = []
     for _, node in graph.nodes.items():
+        node_type, metadata = _get_node_info(node)
         nodes.append(
             UiPathRuntimeNode(
                 id=node.id,
                 name=node.name or node.id,
-                type=_get_node_type(node),
-                metadata=_get_node_metadata(node),
+                type=node_type,
+                metadata=metadata,
                 subgraph=None,
             )
         )
@@ -253,13 +264,14 @@ def get_graph_schema(
 
     nodes: list[UiPathRuntimeNode] = []
     for node_id, node in graph.nodes.items():
+        node_type, metadata = _get_node_info(node)
         subgraph: UiPathRuntimeGraph | None = subgraphs_dict.get(node_id)
         nodes.append(
             UiPathRuntimeNode(
                 id=node.id,
                 name=node.name or node.id,
-                type=_get_node_type(node),
-                metadata=_get_node_metadata(node),
+                type=node_type,
+                metadata=metadata,
                 subgraph=subgraph,
             )
         )