uipath-langchain 0.0.128__tar.gz → 0.0.130__tar.gz

{uipath_langchain-0.0.128 → uipath_langchain-0.0.130}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.128
+Version: 0.0.130
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
@@ -25,7 +25,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.44
+Requires-Dist: uipath<2.2.0,>=2.1.49
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.128 → uipath_langchain-0.0.130}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "uipath-langchain"
-version = "0.0.128"
+version = "0.0.130"
 description = "UiPath Langchain"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 dependencies = [
-    "uipath>=2.1.44, <2.2.0",
+    "uipath>=2.1.49, <2.2.0",
     "langgraph>=0.5.0, <0.7.0",
     "langchain-core>=0.3.34",
     "langgraph-checkpoint-sqlite>=2.0.3",

uipath_langchain-0.0.130/src/uipath_langchain/_cli/_runtime/_context.py

@@ -0,0 +1,21 @@
+from typing import Any, Optional, Union
+
+from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+from langgraph.graph import StateGraph
+from uipath._cli._runtime._contracts import UiPathRuntimeContext
+
+from .._utils._graph import LangGraphConfig
+
+
+class LangGraphRuntimeContext(UiPathRuntimeContext):
+    """Context information passed throughout the runtime execution."""
+
+    langgraph_config: Optional[LangGraphConfig] = None
+    state_graph: Optional[StateGraph[Any, Any]] = None
+    output: Optional[Any] = None
+    state: Optional[Any] = (
+        None  # TypedDict issue, the actual type is: Optional[langgraph.types.StateSnapshot]
+    )
+    memory: Optional[AsyncSqliteSaver] = None
+    langsmith_tracing_enabled: Union[str, bool, None] = False
+    resume_triggers_table: str = "__uipath_resume_triggers"

{uipath_langchain-0.0.128 → uipath_langchain-0.0.130}/src/uipath_langchain/_cli/_runtime/_runtime.py

@@ -50,8 +50,6 @@ class LangGraphRuntime(UiPathBaseRuntime):
         """
         _instrument_traceable_attributes()
 
-        await self.validate()
-
         if self.context.state_graph is None:
             return None
 
@@ -196,17 +194,6 @@ class LangGraphRuntime(UiPathBaseRuntime):
     async def validate(self) -> None:
         """Validate runtime inputs."""
         """Load and validate the graph configuration ."""
-        try:
-            if self.context.input:
-                self.context.input_json = json.loads(self.context.input)
-        except json.JSONDecodeError as e:
-            raise LangGraphRuntimeError(
-                "INPUT_INVALID_JSON",
-                "Invalid JSON input",
-                "The input data is not valid JSON.",
-                UiPathErrorCategory.USER,
-            ) from e
-
         if self.context.langgraph_config is None:
             self.context.langgraph_config = LangGraphConfig()
             if not self.context.langgraph_config.exists:

uipath_langchain-0.0.130/src/uipath_langchain/_cli/cli_eval.py

@@ -0,0 +1,68 @@
+import asyncio
+from os import environ as env
+from typing import List, Optional
+
+from uipath._cli._evals._runtime import UiPathEvalContext, UiPathEvalRuntime
+from uipath._cli._runtime._contracts import (
+    UiPathRuntimeFactory,
+)
+from uipath._cli._utils._eval_set import EvalHelpers
+from uipath._cli.middlewares import MiddlewareResult
+from uipath.eval._helpers import auto_discover_entrypoint
+
+from uipath_langchain._cli._runtime._context import LangGraphRuntimeContext
+from uipath_langchain._cli._runtime._runtime import LangGraphRuntime
+from uipath_langchain._cli._utils._graph import LangGraphConfig
+
+
+def langgraph_eval_middleware(
+    entrypoint: Optional[str], eval_set: Optional[str], eval_ids: List[str], **kwargs
+) -> MiddlewareResult:
+    # Add default env variables
+    env["UIPATH_REQUESTING_PRODUCT"] = "uipath-python-sdk"
+    env["UIPATH_REQUESTING_FEATURE"] = "langgraph-agent"
+
+    config = LangGraphConfig()
+    if not config.exists:
+        return MiddlewareResult(
+            should_continue=True
+        )  # Continue with normal flow if no langgraph.json
+
+    eval_context = UiPathEvalContext.with_defaults(**kwargs)
+    eval_context.eval_set = eval_set or EvalHelpers.auto_discover_eval_set()
+    eval_context.eval_ids = eval_ids
+
+    try:
+        runtime_entrypoint = entrypoint or auto_discover_entrypoint()
+
+        def generate_runtime_context(
+            context_entrypoint: str, langgraph_config: LangGraphConfig, **context_kwargs
+        ) -> LangGraphRuntimeContext:
+            context = LangGraphRuntimeContext.with_defaults(**context_kwargs)
+            context.langgraph_config = langgraph_config
+            context.entrypoint = context_entrypoint
+            return context
+
+        runtime_factory = UiPathRuntimeFactory(
+            LangGraphRuntime,
+            LangGraphRuntimeContext,
+            context_generator=lambda **context_kwargs: generate_runtime_context(
+                context_entrypoint=runtime_entrypoint,
+                langgraph_config=config,
+                **context_kwargs,
+            ),
+        )
+
+        async def execute():
+            async with UiPathEvalRuntime.from_eval_context(
+                factory=runtime_factory, context=eval_context
+            ) as eval_runtime:
+                await eval_runtime.execute()
+
+        asyncio.run(execute())
+        return MiddlewareResult(should_continue=False)
+
+    except Exception as e:
+        return MiddlewareResult(
+            should_continue=False, error_message=f"Error running evaluation: {str(e)}"
+        )

{uipath_langchain-0.0.128 → uipath_langchain-0.0.130}/src/uipath_langchain/_cli/cli_run.py

@@ -3,21 +3,20 @@ import os
 from os import environ as env
 from typing import Optional
 
-from dotenv import load_dotenv
 from uipath._cli.middlewares import MiddlewareResult
 
-from ._runtime._context import LangGraphRuntimeContextBuilder
 from ._runtime._exception import LangGraphRuntimeError
-from ._runtime._runtime import LangGraphRuntime
+from ._runtime._runtime import (  # type: ignore[attr-defined]
+    LangGraphRuntime,
+    LangGraphRuntimeContext,
+)
 from ._utils._graph import LangGraphConfig
 
-load_dotenv()
-
 
 def langgraph_run_middleware(
     entrypoint: Optional[str], input: Optional[str], resume: bool, **kwargs
 ) -> MiddlewareResult:
-    """Middleware to handle langgraph execution"""
+    """Middleware to handle LangGraph execution"""
     config = LangGraphConfig()
     if not config.exists:
         return MiddlewareResult(
@@ -29,14 +28,11 @@ def langgraph_run_middleware(
         env["UIPATH_REQUESTING_PRODUCT"] = "uipath-python-sdk"
         env["UIPATH_REQUESTING_FEATURE"] = "langgraph-agent"
 
-        context = (
-            LangGraphRuntimeContextBuilder()
-            .with_defaults(**kwargs)
-            .with_langgraph_config(config)
-            .with_entrypoint(entrypoint)
-            .with_input(input_data=input, input_file=kwargs.get("input_file"))
-            .with_resume(resume)
-        ).build()
+        context = LangGraphRuntimeContext.with_defaults(**kwargs)
+        context.langgraph_config = config
+        context.entrypoint = entrypoint
+        context.input = input
+        context.resume = resume
 
         async def execute():
             async with LangGraphRuntime.from_context(context) as runtime:

{uipath_langchain-0.0.128 → uipath_langchain-0.0.130}/uv.lock

@@ -2746,7 +2746,7 @@ wheels = [
 
 [[package]]
 name = "uipath"
-version = "2.1.44"
+version = "2.1.49"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "azure-monitor-opentelemetry" },
@@ -2764,14 +2764,14 @@ dependencies = [
     { name = "tomli" },
     { name = "truststore" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/09/62/c0d9d884c7b2b01eb78e9445874745eae0422673d9b89335ce890960eda5/uipath-2.1.44.tar.gz", hash = "sha256:4b544c467158d57f6f7b7ac001fa34b959e685830065bb717544b05b32ee237f", size = 1988099, upload-time = "2025-09-15T06:59:47.92Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fe/98/eaa8666dc8c6fe05ca69926fbabf4644a433b0b3be6925047d0b39fbe24d/uipath-2.1.49.tar.gz", hash = "sha256:8c2633932075d04df5e7297e7a3830e4f973e01d301f553d4f451ca0a45d56d6", size = 1987699, upload-time = "2025-09-16T05:31:24.843Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/51/fd/3ae9edea73f5a8223771924b90dbc390c43b70cebed101b27a05caad11fe/uipath-2.1.44-py3-none-any.whl", hash = "sha256:6988df9cac8a2b6bec505c7b816e5c1d80a990f36fe2e853997e8837e7572bfc", size = 215418, upload-time = "2025-09-15T06:59:46.071Z" },
+    { url = "https://files.pythonhosted.org/packages/07/02/5672c40b4e298d02ec06c5d24a66e58c4d6f4484c654a8fdf56b7c3f389d/uipath-2.1.49-py3-none-any.whl", hash = "sha256:ec4a8f9400f48d5c3b7707a1f23a521a2edaf1e5c8ca0c5da47ac910ab7b3a2b", size = 215197, upload-time = "2025-09-16T05:31:23.031Z" },
 ]
 
 [[package]]
 name = "uipath-langchain"
-version = "0.0.128"
+version = "0.0.130"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },
@@ -2815,7 +2815,7 @@ requires-dist = [
     { name = "openinference-instrumentation-langchain", specifier = ">=0.1.50" },
     { name = "pydantic-settings", specifier = ">=2.6.0" },
     { name = "python-dotenv", specifier = ">=1.0.1" },
-    { name = "uipath", specifier = ">=2.1.44,<2.2.0" },
+    { name = "uipath", specifier = ">=2.1.49,<2.2.0" },
     { name = "uipath-langchain", marker = "extra == 'langchain'", specifier = ">=0.0.2" },
 ]
 provides-extras = ["langchain"]

uipath_langchain-0.0.128/src/uipath_langchain/_cli/_runtime/_context.py

@@ -1,168 +0,0 @@
-from typing import Any, Optional, Union
-from uuid import uuid4
-
-from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
-from langgraph.graph import StateGraph
-from uipath._cli._runtime._contracts import UiPathRuntimeContext, UiPathTraceContext
-
-from .._utils._graph import LangGraphConfig
-
-
-class LangGraphRuntimeContext(UiPathRuntimeContext):
-    """Context information passed throughout the runtime execution."""
-
-    langgraph_config: Optional[LangGraphConfig] = None
-    state_graph: Optional[StateGraph[Any, Any]] = None
-    output: Optional[Any] = None
-    state: Optional[Any] = (
-        None  # TypedDict issue, the actual type is: Optional[langgraph.types.StateSnapshot]
-    )
-    memory: Optional[AsyncSqliteSaver] = None
-    langsmith_tracing_enabled: Union[str, bool, None] = False
-    resume_triggers_table: str = "__uipath_resume_triggers"
-
-
-class LangGraphRuntimeContextBuilder:
-    """Builder class for LangGraphRuntimeContext following the builder pattern."""
-
-    def __init__(self):
-        self._kwargs = {}
-
-    def with_defaults(
-        self, config_path: Optional[str] = None, **kwargs
-    ) -> "LangGraphRuntimeContextBuilder":
-        """Apply default configuration similar to LangGraphRuntimeContext.from_config().
-
-        Args:
-            config_path: Path to the configuration file (defaults to UIPATH_CONFIG_PATH env var or "uipath.json")
-            **kwargs: Additional keyword arguments to pass to with_defaults
-
-        Returns:
-            Self for method chaining
-        """
-        from os import environ as env
-
-        resolved_config_path = config_path or env.get(
-            "UIPATH_CONFIG_PATH", "uipath.json"
-        )
-        self._kwargs["config_path"] = resolved_config_path
-
-        bool_map = {"true": True, "false": False}
-        tracing = env.get("UIPATH_TRACING_ENABLED", True)
-        if isinstance(tracing, str) and tracing.lower() in bool_map:
-            tracing = bool_map[tracing.lower()]
-
-        self._kwargs.update(
-            {
-                "job_id": env.get("UIPATH_JOB_KEY"),
-                "execution_id": env.get("UIPATH_JOB_KEY"),
-                "trace_id": env.get("UIPATH_TRACE_ID"),
-                "tracing_enabled": tracing,
-                "logs_min_level": env.get("LOG_LEVEL", "INFO"),
-                "langsmith_tracing_enabled": env.get("LANGSMITH_TRACING", False),
-                **kwargs,  # Allow overriding defaults with provided kwargs
-            }
-        )
-
-        self._kwargs["trace_context"] = UiPathTraceContext(
-            trace_id=env.get("UIPATH_TRACE_ID"),
-            parent_span_id=env.get("UIPATH_PARENT_SPAN_ID"),
-            root_span_id=env.get("UIPATH_ROOT_SPAN_ID"),
-            enabled=tracing,
-            job_id=env.get("UIPATH_JOB_KEY"),
-            org_id=env.get("UIPATH_ORGANIZATION_ID"),
-            tenant_id=env.get("UIPATH_TENANT_ID"),
-            process_key=env.get("UIPATH_PROCESS_UUID"),
-            folder_key=env.get("UIPATH_FOLDER_KEY"),
-            reference_id=env.get("UIPATH_JOB_KEY") or str(uuid4()),
-        )
-
-        return self
-
-    def with_entrypoint(
-        self, entrypoint: Optional[str]
-    ) -> "LangGraphRuntimeContextBuilder":
-        """Set the entrypoint for the runtime context.
-
-        Args:
-            entrypoint: The entrypoint to execute
-
-        Returns:
-            Self for method chaining
-        """
-        if entrypoint is not None:
-            self._kwargs["entrypoint"] = entrypoint
-        return self
-
-    def with_input(
-        self, input_data: Optional[str] = None, input_file: Optional[str] = None
-    ) -> "LangGraphRuntimeContextBuilder":
-        """Set the input data for the runtime context.
-
-        Args:
-            input_data: The input data as a string
-            input_file: Path to the input file
-
-        Returns:
-            Self for method chaining
-        """
-        if input_data is not None:
-            self._kwargs["input"] = input_data
-        if input_file is not None:
-            self._kwargs["input_file"] = input_file
-        return self
-
-    def with_resume(self, enable: bool = True) -> "LangGraphRuntimeContextBuilder":
-        """Enable or disable resume mode for the runtime context.
-
-        Args:
-            enable: Whether to enable resume mode (defaults to True)
-
-        Returns:
-            Self for method chaining
-        """
-        self._kwargs["resume"] = enable
-        return self
-
-    def with_langgraph_config(
-        self, config: LangGraphConfig
-    ) -> "LangGraphRuntimeContextBuilder":
-        """Set the LangGraph configuration.
-
-        Args:
-            config: The LangGraph configuration
-
-        Returns:
-            Self for method chaining
-        """
-        self._kwargs["langgraph_config"] = config
-        return self
-
-    def mark_eval_run(self, enable: bool = True) -> "LangGraphRuntimeContextBuilder":
-        """Mark this as an evaluation run.
-
-        Args:
-            enable: Whether this is an eval run (defaults to True)
-
-        Returns:
-            Self for method chaining
-        """
-        self._kwargs["is_eval_run"] = enable
-        return self
-
-    def build(self) -> "LangGraphRuntimeContext":
-        """Build and return the LangGraphRuntimeContext instance.
-
-        Returns:
-            A configured LangGraphRuntimeContext instance
-        """
-        config_path = self._kwargs.pop("config_path", None)
-        if config_path:
-            # Create context from config first, then update with any additional kwargs
-            context = LangGraphRuntimeContext.from_config(config_path)
-            for key, value in self._kwargs.items():
-                if hasattr(context, key):
-                    setattr(context, key, value)
-            return context
-        else:
-            return LangGraphRuntimeContext(**self._kwargs)

uipath_langchain-0.0.128/src/uipath_langchain/_cli/cli_eval.py

@@ -1,63 +0,0 @@
-import asyncio
-from os import environ as env
-from typing import List, Optional
-
-from uipath._cli._evals._runtime import UiPathEvalContext, UiPathEvalRuntime
-from uipath._cli._runtime._contracts import (
-    UiPathRuntimeContextBuilder,
-    UiPathRuntimeFactory,
-)
-from uipath._cli.middlewares import MiddlewareResult
-
-from uipath_langchain._cli._runtime._context import (
-    LangGraphRuntimeContext,
-    LangGraphRuntimeContextBuilder,
-)
-from uipath_langchain._cli._runtime._runtime import LangGraphRuntime
-from uipath_langchain._cli._utils._graph import LangGraphConfig
-
-
-def langgraph_eval_middleware(
-    entrypoint: Optional[str], eval_set: Optional[str], eval_ids: List[str], **kwargs
-) -> MiddlewareResult:
-    def generate_eval_context(
-        runtime_context: LangGraphRuntimeContext,
-    ) -> UiPathEvalContext[LangGraphRuntimeContext]:
-        base_context = UiPathRuntimeContextBuilder().with_defaults().build()
-        return UiPathEvalContext(
-            runtime_context=runtime_context,
-            **kwargs,
-            **base_context.model_dump(),
-        )
-
-    try:
-        runtime_factory = UiPathRuntimeFactory(
-            LangGraphRuntime, LangGraphRuntimeContext
-        )
-        # Add default env variables
-        env["UIPATH_REQUESTING_PRODUCT"] = "uipath-python-sdk"
-        env["UIPATH_REQUESTING_FEATURE"] = "langgraph-agent"
-
-        context = (
-            LangGraphRuntimeContextBuilder()
-            .with_defaults(**kwargs)
-            .with_langgraph_config(LangGraphConfig())
-            .with_entrypoint(entrypoint)
-            .mark_eval_run()
-        ).build()
-
-        async def execute():
-            async with UiPathEvalRuntime[
-                LangGraphRuntime, LangGraphRuntimeContext
-            ].from_eval_context(
-                factory=runtime_factory, context=generate_eval_context(context)
-            ) as eval_runtime:
-                await eval_runtime.execute()
-
-        asyncio.run(execute())
-        return MiddlewareResult(should_continue=False)
-
-    except Exception as e:
-        return MiddlewareResult(
-            should_continue=False, error_message=f"Error running evaluation: {str(e)}"
-        )