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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.144
+Version: 0.0.146
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
@@ -26,7 +26,7 @@ Requires-Dist: openai>=1.65.5
 Requires-Dist: openinference-instrumentation-langchain>=0.1.50
 Requires-Dist: pydantic-settings>=2.6.0
 Requires-Dist: python-dotenv>=1.0.1
-Requires-Dist: uipath<2.2.0,>=2.1.103
+Requires-Dist: uipath<2.2.0,>=2.1.110
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.144 → uipath_langchain-0.0.146}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "uipath-langchain"
-version = "0.0.144"
+version = "0.0.146"
 description = "UiPath Langchain"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 dependencies = [
-    "uipath>=2.1.103, <2.2.0",
+    "uipath>=2.1.110, <2.2.0",
     "langgraph>=0.5.0, <0.7.0",
     "langchain-core>=0.3.34",
     "langgraph-checkpoint-sqlite>=2.0.3",
@@ -111,4 +111,4 @@ asyncio_mode = "auto"
 name = "testpypi"
 url = "https://test.pypi.org/simple/"
 publish-url = "https://test.pypi.org/legacy/"
-explicit = true
+explicit = true

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

@@ -2,12 +2,14 @@ import logging
 import os
 from contextlib import asynccontextmanager
 from typing import Any, AsyncGenerator, AsyncIterator, Optional, Sequence
+from uuid import uuid4
 
 from langchain_core.runnables.config import RunnableConfig
 from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
 from langgraph.errors import EmptyInputError, GraphRecursionError, InvalidUpdateError
 from langgraph.graph.state import CompiledStateGraph, StateGraph
 from langgraph.types import Interrupt, StateSnapshot
+from typing_extensions import override
 from uipath._cli._runtime._contracts import (
     UiPathBaseRuntime,
     UiPathBreakpointResult,
@@ -17,12 +19,14 @@ from uipath._cli._runtime._contracts import (
     UiPathRuntimeResult,
     UiPathRuntimeStatus,
 )
+from uipath._cli.models.runtime_schema import Entrypoint
 from uipath._events._events import (
     UiPathAgentMessageEvent,
     UiPathAgentStateEvent,
     UiPathRuntimeEvent,
 )
 
+from .._utils._schema import generate_schema_from_graph
 from ._context import LangGraphRuntimeContext
 from ._exception import LangGraphErrorCode, LangGraphRuntimeError
 from ._graph_resolver import AsyncResolver, LangGraphJsonResolver
@@ -481,6 +485,21 @@ class LangGraphScriptRuntime(LangGraphRuntime):
         self.resolver = LangGraphJsonResolver(entrypoint=entrypoint)
         super().__init__(context, self.resolver)
 
+    @override
+    async def get_entrypoint(self) -> Entrypoint:
+        """Get entrypoint for this LangGraph runtime."""
+        graph = await self.resolver()
+        compiled_graph = graph.compile()
+        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_details.schema["input"],
+            output=schema_details.schema["output"],
+        )
+
     async def cleanup(self) -> None:
         """Cleanup runtime resources including resolver."""
         await super().cleanup()

uipath_langchain-0.0.146/src/uipath_langchain/_cli/_utils/_schema.py

@@ -0,0 +1,137 @@
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from langgraph.graph.state import CompiledStateGraph
+
+
+@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
+
+    if visited is None:
+        visited = set()
+
+    has_circular = False
+
+    if isinstance(schema, dict):
+        if "$ref" in schema:
+            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_parts:
+                ref_schema = ref_schema.get(part, {})
+
+            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):
+        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, False
+
+
+def process_nullable_types(
+    schema: Dict[str, Any] | list[Any] | Any,
+) -> Dict[str, Any] | list[Any]:
+    """Process the schema to handle nullable types by removing anyOf with null and keeping the base type."""
+    if isinstance(schema, dict):
+        if "anyOf" in schema and len(schema["anyOf"]) == 2:
+            types = [t.get("type") for t in schema["anyOf"]]
+            if "null" in types:
+                non_null_type = next(
+                    t for t in schema["anyOf"] if t.get("type") != "null"
+                )
+                return non_null_type
+
+        return {k: process_nullable_types(v) for k, v in schema.items()}
+    elif isinstance(schema, list):
+        return [process_nullable_types(item) for item in schema]
+    return schema
+
+
+def generate_schema_from_graph(
+    graph: CompiledStateGraph[Any, Any, 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": []},
+    }
+
+    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, input_circular_dependency = resolve_refs(
+                input_schema
+            )
+
+            # Process the schema to handle nullable types
+            processed_properties = process_nullable_types(
+                unpacked_ref_def_properties.get("properties", {})
+            )
+
+            schema["input"]["properties"] = processed_properties
+            schema["input"]["required"] = unpacked_ref_def_properties.get(
+                "required", []
+            )
+
+    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, output_circular_dependency = resolve_refs(
+                output_schema
+            )
+
+            # Process the schema to handle nullable types
+            processed_properties = process_nullable_types(
+                unpacked_ref_def_properties.get("properties", {})
+            )
+
+            schema["output"]["properties"] = processed_properties
+            schema["output"]["required"] = unpacked_ref_def_properties.get(
+                "required", []
+            )
+
+    return SchemaDetails(schema, input_circular_dependency, output_circular_dependency)

{uipath_langchain-0.0.144 → uipath_langchain-0.0.146}/src/uipath_langchain/_cli/cli_eval.py

@@ -6,8 +6,9 @@ from openinference.instrumentation.langchain import (
     get_current_span,
 )
 from uipath._cli._evals._console_progress_reporter import ConsoleProgressReporter
+from uipath._cli._evals._evaluate import evaluate
 from uipath._cli._evals._progress_reporter import StudioWebProgressReporter
-from uipath._cli._evals._runtime import UiPathEvalContext, UiPathEvalRuntime
+from uipath._cli._evals._runtime import UiPathEvalContext
 from uipath._cli._runtime._contracts import (
     UiPathRuntimeFactory,
 )
@@ -82,14 +83,7 @@ def langgraph_eval_middleware(
 
         runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
 
-        async def execute():
-            async with UiPathEvalRuntime.from_eval_context(
-                factory=runtime_factory, context=eval_context, event_bus=event_bus
-            ) as eval_runtime:
-                await eval_runtime.execute()
-                await event_bus.wait_for_all()
-
-        asyncio.run(execute())
+        asyncio.run(evaluate(runtime_factory, eval_context, event_bus))
         return MiddlewareResult(should_continue=False)
 
     except Exception as e:

{uipath_langchain-0.0.144 → uipath_langchain-0.0.146}/src/uipath_langchain/_cli/cli_init.py

@@ -6,7 +6,7 @@ import shutil
 import uuid
 from collections.abc import Generator
 from enum import Enum
-from typing import Any, Callable, Dict, overload
+from typing import Any, Callable, overload
 
 import click
 from langgraph.graph.state import CompiledStateGraph
@@ -14,6 +14,8 @@ from uipath._cli._utils._console import ConsoleLogger
 from uipath._cli._utils._parse_ast import generate_bindings_json  # type: ignore
 from uipath._cli.middlewares import MiddlewareResult
 
+from uipath_langchain._cli._utils._schema import generate_schema_from_graph
+
 from ._utils._graph import LangGraphConfig
 
 console = ConsoleLogger()
@@ -27,88 +29,6 @@ class FileOperationStatus(str, Enum):
     SKIPPED = "skipped"
 
 
-def resolve_refs(schema, root=None):
-    """Recursively resolves $ref references in a JSON schema."""
-    if root is None:
-        root = schema  # Store the root schema to resolve $refs
-
-    if isinstance(schema, dict):
-        if "$ref" in schema:
-            ref_path = schema["$ref"].lstrip("#/").split("/")
-            ref_schema = root
-            for part in ref_path:
-                ref_schema = ref_schema.get(part, {})
-            return resolve_refs(ref_schema, root)
-
-        return {k: resolve_refs(v, root) for k, v in schema.items()}
-
-    elif isinstance(schema, list):
-        return [resolve_refs(item, root) for item in schema]
-
-    return schema
-
-
-def process_nullable_types(
-    schema: Dict[str, Any] | list[Any] | Any,
-) -> Dict[str, Any] | list[Any]:
-    """Process the schema to handle nullable types by removing anyOf with null and keeping the base type."""
-    if isinstance(schema, dict):
-        if "anyOf" in schema and len(schema["anyOf"]) == 2:
-            types = [t.get("type") for t in schema["anyOf"]]
-            if "null" in types:
-                non_null_type = next(
-                    t for t in schema["anyOf"] if t.get("type") != "null"
-                )
-                return non_null_type
-
-        return {k: process_nullable_types(v) for k, v in schema.items()}
-    elif isinstance(schema, list):
-        return [process_nullable_types(item) for item in schema]
-    return schema
-
-
-def generate_schema_from_graph(
-    graph: CompiledStateGraph[Any, Any, Any],
-) -> Dict[str, Any]:
-    """Extract input/output schema from a LangGraph graph"""
-    schema = {
-        "input": {"type": "object", "properties": {}, "required": []},
-        "output": {"type": "object", "properties": {}, "required": []},
-    }
-
-    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)
-
-            # Process the schema to handle nullable types
-            processed_properties = process_nullable_types(
-                unpacked_ref_def_properties.get("properties", {})
-            )
-
-            schema["input"]["properties"] = processed_properties
-            schema["input"]["required"] = unpacked_ref_def_properties.get(
-                "required", []
-            )
-
-    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)
-
-            # Process the schema to handle nullable types
-            processed_properties = process_nullable_types(
-                unpacked_ref_def_properties.get("properties", {})
-            )
-
-            schema["output"]["properties"] = processed_properties
-            schema["output"]["required"] = unpacked_ref_def_properties.get(
-                "required", []
-            )
-
-    return schema
-
-
 def generate_agent_md_file(
     target_directory: str,
     file_name: str,
@@ -255,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()
 
@@ -277,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(
@@ -323,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/src/uipath_langchain/runtime_factories.py

@@ -0,0 +1,21 @@
+"""Runtime factory for LangGraph projects."""
+
+from uipath._cli._runtime._contracts import UiPathRuntimeFactory
+
+from ._cli._runtime._context import LangGraphRuntimeContext
+from ._cli._runtime._runtime import LangGraphScriptRuntime
+
+
+class LangGraphRuntimeFactory(
+    UiPathRuntimeFactory[LangGraphScriptRuntime, LangGraphRuntimeContext]
+):
+    """Factory for LangGraph runtimes."""
+
+    def __init__(self):
+        super().__init__(
+            LangGraphScriptRuntime,
+            LangGraphRuntimeContext,
+            context_generator=lambda **kwargs: LangGraphRuntimeContext.with_defaults(
+                **kwargs
+            ),
+        )

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"]