uipath-langchain 0.0.145__tar.gz → 0.0.146__tar.gz

{uipath_langchain-0.0.145 → uipath_langchain-0.0.146}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.145
+Version: 0.0.146
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python

{uipath_langchain-0.0.145 → uipath_langchain-0.0.146}/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"

{uipath_langchain-0.0.145 → uipath_langchain-0.0.146}/src/uipath_langchain/_cli/_runtime/_runtime.py

@@ -490,14 +490,14 @@ class LangGraphScriptRuntime(LangGraphRuntime):
         """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:

{uipath_langchain-0.0.145 → uipath_langchain-0.0.146}/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)

{uipath_langchain-0.0.145 → uipath_langchain-0.0.146}/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)

uipath_langchain-0.0.146/tests/cli/test_schema.py

@@ -0,0 +1,266 @@
+"""Tests for schema utility functions."""
+
+from unittest.mock import MagicMock
+
+from pydantic import BaseModel, Field
+
+from uipath_langchain._cli._utils._schema import (
+    generate_schema_from_graph,
+    resolve_refs,
+)
+
+
+class TestResolveRefs:
+    """Tests for the resolve_refs function."""
+
+    def test_simple_schema_without_refs(self):
+        """Should return schema unchanged when no $refs exist."""
+        schema = {
+            "type": "object",
+            "properties": {"name": {"type": "string"}, "age": {"type": "integer"}},
+        }
+
+        result, has_circular = resolve_refs(schema)
+
+        assert result == schema
+        assert has_circular is False
+
+    def test_simple_ref_resolution(self):
+        """Should resolve a simple $ref to its definition."""
+        schema = {
+            "properties": {"user": {"$ref": "#/$defs/User"}},
+            "$defs": {
+                "User": {
+                    "type": "object",
+                    "properties": {"name": {"type": "string"}},
+                }
+            },
+        }
+
+        result, has_circular = resolve_refs(schema)
+
+        assert result["properties"]["user"]["type"] == "object"
+        assert result["properties"]["user"]["properties"]["name"]["type"] == "string"
+        assert has_circular is False
+
+    def test_circular_dependency_detection(self):
+        """Should detect circular dependencies in schema."""
+        schema = {
+            "properties": {"node": {"$ref": "#/$defs/Node"}},
+            "$defs": {
+                "Node": {
+                    "type": "object",
+                    "properties": {
+                        "value": {"type": "string"},
+                        "next": {"$ref": "#/$defs/Node"},
+                    },
+                }
+            },
+        }
+
+        result, has_circular = resolve_refs(schema)
+
+        assert has_circular is True
+        # Check that circular ref was replaced with simplified schema
+        assert result["properties"]["node"]["properties"]["next"]["type"] == "object"
+        assert (
+            "Circular reference"
+            in result["properties"]["node"]["properties"]["next"]["description"]
+        )
+
+    def test_nested_refs_in_properties(self):
+        """Should resolve nested $refs in object properties."""
+        schema = {
+            "properties": {
+                "person": {"$ref": "#/$defs/Person"},
+                "address": {"$ref": "#/$defs/Address"},
+            },
+            "$defs": {
+                "Person": {
+                    "type": "object",
+                    "properties": {"name": {"type": "string"}},
+                },
+                "Address": {
+                    "type": "object",
+                    "properties": {"street": {"type": "string"}},
+                },
+            },
+        }
+
+        result, has_circular = resolve_refs(schema)
+
+        assert result["properties"]["person"]["type"] == "object"
+        assert result["properties"]["person"]["properties"]["name"]["type"] == "string"
+        assert result["properties"]["address"]["type"] == "object"
+        assert (
+            result["properties"]["address"]["properties"]["street"]["type"] == "string"
+        )
+        assert has_circular is False
+
+    def test_refs_in_arrays(self):
+        """Should resolve $refs inside array items."""
+        schema = {
+            "properties": {
+                "users": {
+                    "type": "array",
+                    "items": {"$ref": "#/$defs/User"},
+                }
+            },
+            "$defs": {
+                "User": {
+                    "type": "object",
+                    "properties": {"id": {"type": "integer"}},
+                }
+            },
+        }
+
+        result, has_circular = resolve_refs(schema)
+
+        assert result["properties"]["users"]["items"]["type"] == "object"
+        assert (
+            result["properties"]["users"]["items"]["properties"]["id"]["type"]
+            == "integer"
+        )
+        assert has_circular is False
+
+    def test_multiple_circular_dependencies(self):
+        """Should handle multiple circular dependencies in same schema."""
+        schema = {
+            "properties": {
+                "node1": {"$ref": "#/$defs/Node"},
+                "node2": {"$ref": "#/$defs/Node"},
+            },
+            "$defs": {
+                "Node": {
+                    "type": "object",
+                    "properties": {
+                        "next": {"$ref": "#/$defs/Node"},
+                    },
+                }
+            },
+        }
+
+        result, has_circular = resolve_refs(schema)
+
+        assert has_circular is True
+
+
+class TestGenerateSchemaFromGraph:
+    """Tests for the generate_schema_from_graph function."""
+
+    def test_graph_without_schemas(self):
+        """Should return empty schemas when graph has no input/output schemas."""
+        mock_graph = MagicMock()
+        del mock_graph.input_schema
+        del mock_graph.output_schema
+
+        result = generate_schema_from_graph(mock_graph)
+
+        assert result.schema["input"] == {
+            "type": "object",
+            "properties": {},
+            "required": [],
+        }
+        assert result.schema["output"] == {
+            "type": "object",
+            "properties": {},
+            "required": [],
+        }
+        assert result.has_input_circular_dependency is False
+        assert result.has_output_circular_dependency is False
+
+    def test_graph_with_simple_schemas(self):
+        """Should extract input and output schemas from graph."""
+
+        class InputModel(BaseModel):
+            query: str = Field(description="User query")
+            max_results: int = Field(default=10)
+
+        class OutputModel(BaseModel):
+            response: str = Field(description="Agent response")
+
+        mock_graph = MagicMock()
+        mock_graph.input_schema = InputModel
+        mock_graph.output_schema = OutputModel
+
+        result = generate_schema_from_graph(mock_graph)
+
+        assert "query" in result.schema["input"]["properties"]
+        assert "max_results" in result.schema["input"]["properties"]
+        assert result.schema["input"]["properties"]["query"]["type"] == "string"
+        assert "response" in result.schema["output"]["properties"]
+        assert result.schema["output"]["properties"]["response"]["type"] == "string"
+        assert result.has_input_circular_dependency is False
+        assert result.has_output_circular_dependency is False
+
+    def test_graph_with_circular_input_schema(self):
+        """Should detect circular dependencies in input schema."""
+
+        class NodeInput(BaseModel):
+            value: str
+            children: list["NodeInput"] = Field(default_factory=list)
+
+        mock_graph = MagicMock()
+        mock_graph.input_schema = NodeInput
+        del mock_graph.output_schema
+
+        result = generate_schema_from_graph(mock_graph)
+
+        assert result.has_input_circular_dependency is True
+        assert result.has_output_circular_dependency is False
+        assert "value" in result.schema["input"]["properties"]
+
+    def test_graph_with_circular_output_schema(self):
+        """Should detect circular dependencies in output schema."""
+
+        class TreeOutput(BaseModel):
+            name: str
+            parent: "TreeOutput | None" = None
+
+        mock_graph = MagicMock()
+        del mock_graph.input_schema
+        mock_graph.output_schema = TreeOutput
+
+        result = generate_schema_from_graph(mock_graph)
+
+        assert result.has_input_circular_dependency is False
+        assert result.has_output_circular_dependency is True
+        assert "name" in result.schema["output"]["properties"]
+
+    def test_graph_with_both_circular_schemas(self):
+        """Should detect circular dependencies in both input and output schemas."""
+
+        class CircularInput(BaseModel):
+            data: str
+            ref: "CircularInput | None" = None
+
+        class CircularOutput(BaseModel):
+            result: str
+            next: "CircularOutput | None" = None
+
+        mock_graph = MagicMock()
+        mock_graph.input_schema = CircularInput
+        mock_graph.output_schema = CircularOutput
+
+        result = generate_schema_from_graph(mock_graph)
+
+        assert result.has_input_circular_dependency is True
+        assert result.has_output_circular_dependency is True
+        assert "data" in result.schema["input"]["properties"]
+        assert "result" in result.schema["output"]["properties"]
+
+    def test_graph_with_required_fields(self):
+        """Should extract required fields from schemas."""
+
+        class StrictModel(BaseModel):
+            required_field: str
+            optional_field: str | None = None
+
+        mock_graph = MagicMock()
+        mock_graph.input_schema = StrictModel
+        del mock_graph.output_schema
+
+        result = generate_schema_from_graph(mock_graph)
+
+        assert "required_field" in result.schema["input"]["required"]
+        assert "optional_field" not in result.schema["input"]["required"]