fix: handle input output schema circular dependencies

Author: radu-mocanu

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath-langchain"
-version = "0.0.145"
+version = "0.0.146"
 description = "UiPath Langchain"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

src/uipath_langchain/_cli/_runtime/_runtime.py

@@ -490,14 +490,14 @@ async def get_entrypoint(self) -> Entrypoint:
         """Get entrypoint for this LangGraph runtime."""
         graph = await self.resolver()
         compiled_graph = graph.compile()
-        schema = generate_schema_from_graph(compiled_graph)
+        schema_details = generate_schema_from_graph(compiled_graph)
 
         return Entrypoint(
             file_path=self.context.entrypoint,  # type: ignore[call-arg]
             unique_id=str(uuid4()),
             type="agent",
-            input=schema["input"],
-            output=schema["output"],
+            input=schema_details.schema["input"],
+            output=schema_details.schema["output"],
         )
 
     async def cleanup(self) -> None:

src/uipath_langchain/_cli/_utils/_schema.py

@@ -1,27 +1,73 @@
+from dataclasses import dataclass
 from typing import Any, Dict
 
 from langgraph.graph.state import CompiledStateGraph
 
 
-def resolve_refs(schema, root=None):
-    """Recursively resolves $ref references in a JSON schema."""
+@dataclass
+class SchemaDetails:
+    schema: dict[str, Any]
+    has_input_circular_dependency: bool
+    has_output_circular_dependency: bool
+
+
+def resolve_refs(schema, root=None, visited=None):
+    """Recursively resolves $ref references in a JSON schema, handling circular references.
+
+    Returns:
+        tuple: (resolved_schema, has_circular_dependency)
+    """
     if root is None:
-        root = schema  # Store the root schema to resolve $refs
+        root = schema
+
+    if visited is None:
+        visited = set()
+
+    has_circular = False
 
     if isinstance(schema, dict):
         if "$ref" in schema:
-            ref_path = schema["$ref"].lstrip("#/").split("/")
+            ref_path = schema["$ref"]
+
+            if ref_path in visited:
+                # Circular dependency detected
+                return {
+                    "type": "object",
+                    "description": f"Circular reference to {ref_path}",
+                }, True
+
+            visited.add(ref_path)
+
+            # Resolve the reference
+            ref_parts = ref_path.lstrip("#/").split("/")
             ref_schema = root
-            for part in ref_path:
+            for part in ref_parts:
                 ref_schema = ref_schema.get(part, {})
-            return resolve_refs(ref_schema, root)
 
-        return {k: resolve_refs(v, root) for k, v in schema.items()}
+            result, circular = resolve_refs(ref_schema, root, visited)
+            has_circular = has_circular or circular
+
+            # Remove from visited after resolution (allows the same ref in different branches)
+            visited.discard(ref_path)
+
+            return result, has_circular
+
+        resolved_dict = {}
+        for k, v in schema.items():
+            resolved_value, circular = resolve_refs(v, root, visited)
+            resolved_dict[k] = resolved_value
+            has_circular = has_circular or circular
+        return resolved_dict, has_circular
 
     elif isinstance(schema, list):
-        return [resolve_refs(item, root) for item in schema]
+        resolved_list = []
+        for item in schema:
+            resolved_item, circular = resolve_refs(item, root, visited)
+            resolved_list.append(resolved_item)
+            has_circular = has_circular or circular
+        return resolved_list, has_circular
 
-    return schema
+    return schema, False
 
 
 def process_nullable_types(
@@ -45,8 +91,10 @@ def process_nullable_types(
 
 def generate_schema_from_graph(
     graph: CompiledStateGraph[Any, Any, Any],
-) -> Dict[str, Any]:
+) -> SchemaDetails:
     """Extract input/output schema from a LangGraph graph"""
+    input_circular_dependency = False
+    output_circular_dependency = False
     schema = {
         "input": {"type": "object", "properties": {}, "required": []},
         "output": {"type": "object", "properties": {}, "required": []},
@@ -55,7 +103,9 @@ def generate_schema_from_graph(
     if hasattr(graph, "input_schema"):
         if hasattr(graph.input_schema, "model_json_schema"):
             input_schema = graph.input_schema.model_json_schema()
-            unpacked_ref_def_properties = resolve_refs(input_schema)
+            unpacked_ref_def_properties, input_circular_dependency = resolve_refs(
+                input_schema
+            )
 
             # Process the schema to handle nullable types
             processed_properties = process_nullable_types(
@@ -70,7 +120,9 @@ def generate_schema_from_graph(
     if hasattr(graph, "output_schema"):
         if hasattr(graph.output_schema, "model_json_schema"):
             output_schema = graph.output_schema.model_json_schema()
-            unpacked_ref_def_properties = resolve_refs(output_schema)
+            unpacked_ref_def_properties, output_circular_dependency = resolve_refs(
+                output_schema
+            )
 
             # Process the schema to handle nullable types
             processed_properties = process_nullable_types(
@@ -82,4 +134,4 @@ def generate_schema_from_graph(
                 "required", []
             )
 
-    return schema
+    return SchemaDetails(schema, input_circular_dependency, output_circular_dependency)

src/uipath_langchain/_cli/cli_init.py

@@ -175,7 +175,7 @@ async def langgraph_init_middleware_async(
                     else loaded_graph
                 )
                 compiled_graph = state_graph.compile()
-                graph_schema = generate_schema_from_graph(compiled_graph)
+                schema_details = generate_schema_from_graph(compiled_graph)
 
                 mermaids[graph.name] = compiled_graph.get_graph(xray=1).draw_mermaid()
 
@@ -197,11 +197,17 @@ async def langgraph_init_middleware_async(
                     "filePath": graph.name,
                     "uniqueId": str(uuid.uuid4()),
                     "type": "agent",
-                    "input": graph_schema["input"],
-                    "output": graph_schema["output"],
+                    "input": schema_details.schema["input"],
+                    "output": schema_details.schema["output"],
                 }
                 entrypoints.append(new_entrypoint)
 
+                warning_circular_deps = f" schema of graph '{graph.name}' contains circular dependencies. Some types might not be correctly inferred."
+                if schema_details.has_input_circular_dependency:
+                    console.warning("Input" + warning_circular_deps)
+                if schema_details.has_output_circular_dependency:
+                    console.warning("Output" + warning_circular_deps)
+
             except Exception as e:
                 console.error(f"Error during graph load: {e}")
                 return MiddlewareResult(
@@ -243,6 +249,7 @@ async def langgraph_init_middleware_async(
                     should_continue=False,
                     should_include_stacktrace=True,
                 )
+
         console.success(f"Created {click.style(config_path, fg='cyan')} file.")
 
         generate_agents_md_files(options)