uipath-langchain 0.0.127__py3-none-any.whl → 0.0.128__py3-none-any.whl

uipath_langchain/_cli/_runtime/_context.py

@@ -1,8 +1,9 @@
 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
+from uipath._cli._runtime._contracts import UiPathRuntimeContext, UiPathTraceContext
 
 from .._utils._graph import LangGraphConfig
 
@@ -19,3 +20,149 @@ class LangGraphRuntimeContext(UiPathRuntimeContext):
     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/_cli/cli_eval.py

@@ -0,0 +1,63 @@
+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)}"
+        )

uipath_langchain/_cli/cli_run.py

@@ -4,10 +4,9 @@ from os import environ as env
 from typing import Optional
 
 from dotenv import load_dotenv
-from uipath._cli._runtime._contracts import UiPathTraceContext
 from uipath._cli.middlewares import MiddlewareResult
 
-from ._runtime._context import LangGraphRuntimeContext
+from ._runtime._context import LangGraphRuntimeContextBuilder
 from ._runtime._exception import LangGraphRuntimeError
 from ._runtime._runtime import LangGraphRuntime
 from ._utils._graph import LangGraphConfig
@@ -26,45 +25,20 @@ def langgraph_run_middleware(
         )  # Continue with normal flow if no langgraph.json
 
     try:
-        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()]
+        # Add default env variables
+        env["UIPATH_REQUESTING_PRODUCT"] = "uipath-python-sdk"
+        env["UIPATH_REQUESTING_FEATURE"] = "langgraph-agent"
 
-        async def execute():
-            context: LangGraphRuntimeContext = LangGraphRuntimeContext.from_config(
-                env.get("UIPATH_CONFIG_PATH", "uipath.json"), **kwargs
-            )
-            context.entrypoint = entrypoint
-            context.input = input
-            context.resume = resume
-            context.langgraph_config = config
-            context.debug = kwargs.get("debug", False)
-            context.logs_min_level = env.get("LOG_LEVEL", "INFO")
-            context.job_id = env.get("UIPATH_JOB_KEY", None)
-            context.execution_id = env.get("UIPATH_JOB_KEY", None)
-            context.trace_id = env.get("UIPATH_TRACE_ID")
-            context.is_eval_run = kwargs.get("is_eval_run", False)
-            context.tracing_enabled = tracing
-            context.input_file = kwargs.get("input_file", None)
-            context.execution_output_file = kwargs.get("execution_output_file", None)
-            context.trace_context = UiPathTraceContext(
-                enabled=tracing,
-                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"),
-                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"),
-            )
-            context.langsmith_tracing_enabled = env.get("LANGSMITH_TRACING", False)
-
-            # 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(config)
+            .with_entrypoint(entrypoint)
+            .with_input(input_data=input, input_file=kwargs.get("input_file"))
+            .with_resume(resume)
+        ).build()
 
+        async def execute():
             async with LangGraphRuntime.from_context(context) as runtime:
                 if context.resume is False and context.job_id is None:
                     # Delete the previous graph state file at debug time

uipath_langchain/middlewares.py

@@ -1,6 +1,7 @@
 from uipath._cli.middlewares import Middlewares
 
 from ._cli.cli_dev import langgraph_dev_middleware
+from ._cli.cli_eval import langgraph_eval_middleware
 from ._cli.cli_init import langgraph_init_middleware
 from ._cli.cli_new import langgraph_new_middleware
 from ._cli.cli_run import langgraph_run_middleware
@@ -12,3 +13,4 @@ def register_middleware():
     Middlewares.register("run", langgraph_run_middleware)
     Middlewares.register("new", langgraph_new_middleware)
     Middlewares.register("dev", langgraph_dev_middleware)
+    Middlewares.register("eval", langgraph_eval_middleware)

{uipath_langchain-0.0.127.dist-info → uipath_langchain-0.0.128.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.127
+Version: 0.0.128
 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.41
+Requires-Dist: uipath<2.2.0,>=2.1.44
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.127.dist-info → uipath_langchain-0.0.128.dist-info}/RECORD

@@ -1,11 +1,12 @@
 uipath_langchain/__init__.py,sha256=VBrvQn7d3nuOdN7zEnV2_S-uhmkjgEIlXiFVeZxZakQ,80
-uipath_langchain/middlewares.py,sha256=EOWVTr52SFLEf5lzGAvcDN2qbtPsy4_EsFoXlV-cqdY,618
+uipath_langchain/middlewares.py,sha256=6ljfbtWekrYc5G9KWDLSaViJ1DVIaNM-4qeB1BfHywE,731
 uipath_langchain/_cli/__init__.py,sha256=juqd9PbXs4yg45zMJ7BHAOPQjb7sgEbWE9InBtGZhfo,24
 uipath_langchain/_cli/cli_dev.py,sha256=VlI8qgCw-63I97tp_9lbXs-CVcNSjpd2sC13YNZAIuU,1401
+uipath_langchain/_cli/cli_eval.py,sha256=iAXiRuX_IYwQVNC9x-btcqx0YNgCVNCpYRu8ZaQ_glo,2168
 uipath_langchain/_cli/cli_init.py,sha256=xhxJ8tuMSrVUNHvltgyPpOrvgMA-wq9shHeYYwvHILs,8199
 uipath_langchain/_cli/cli_new.py,sha256=dL8-Rri6u67ZZdbb4nT38A5xD_Q3fVnG0UK9VSeKaqg,2563
-uipath_langchain/_cli/cli_run.py,sha256=R-cUi3lO3Qd4ysTXD7PW4sa1RsB427v_Y6xUQxWijfQ,3725
-uipath_langchain/_cli/_runtime/_context.py,sha256=yyzYJDmk2fkH4T5gm4cLGRyXtjLESrpzHBT9euqluTA,817
+uipath_langchain/_cli/cli_run.py,sha256=GJ8t1wZSRG644G5rL_u6GdPSKBI4Muj075Y9YlJSk3c,2202
+uipath_langchain/_cli/_runtime/_context.py,sha256=jY3CZY2gynJO19LOp8HK0qle7cJAUmiYIVFnpEga7K8,5800
 uipath_langchain/_cli/_runtime/_conversation.py,sha256=S1KTx_q-La7ikPRT3nBcIp8t-J9CF0QB0DCduQIIB28,11149
 uipath_langchain/_cli/_runtime/_exception.py,sha256=USKkLYkG-dzjX3fEiMMOHnVUpiXJs_xF0OQXCCOvbYM,546
 uipath_langchain/_cli/_runtime/_input.py,sha256=3IKrZR9xmxYg6l_1TbFpaLOWPDvK8d3nSKIHPGEEGzE,5715
@@ -32,8 +33,8 @@ uipath_langchain/tracers/_instrument_traceable.py,sha256=0e841zVzcPWjOGtmBx0GeHb
 uipath_langchain/tracers/_utils.py,sha256=JOT1tKMdvqjMDtj2WbmbOWMeMlTXBWavxWpogX7KlRA,1543
 uipath_langchain/vectorstores/__init__.py,sha256=w8qs1P548ud1aIcVA_QhBgf_jZDrRMK5Lono78yA8cs,114
 uipath_langchain/vectorstores/context_grounding_vectorstore.py,sha256=TncIXG-YsUlO0R5ZYzWsM-Dj1SVCZbzmo2LraVxXelc,9559
-uipath_langchain-0.0.127.dist-info/METADATA,sha256=-pkEhqb6QF5H9pH-3TVabaJmMZcsWrd-sAH6EMlPhpg,4235
-uipath_langchain-0.0.127.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.127.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.127.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.127.dist-info/RECORD,,
+uipath_langchain-0.0.128.dist-info/METADATA,sha256=j7n4C35F6bOqi7JE4_X-50klv2NTZeO1ov-ab94JEdI,4235
+uipath_langchain-0.0.128.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_langchain-0.0.128.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
+uipath_langchain-0.0.128.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.0.128.dist-info/RECORD,,