Merge branch 'main' of https://github.com/UiPath/uipath-langchain-python into josh/cas-interrupt

Author: JoshParkSJ

pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "uipath-langchain"
-version = "0.7.8"
+version = "0.8.6"
 description = "Python SDK that enables developers to build and deploy LangGraph agents to the UiPath Cloud Platform"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"
 dependencies = [
-    "uipath>=2.9.12, <2.10.0",
+    "uipath>=2.10.0, <2.11.0",
     "uipath-core>=0.5.2, <0.6.0",
-    "uipath-platform>=0.0.4, < 0.1.0",
+    "uipath-platform>=0.0.8, <0.1.0",
     "uipath-runtime>=0.9.1, <0.10.0",
     "langgraph>=1.0.0, <2.0.0",
     "langchain-core>=1.2.11, <2.0.0",
@@ -18,7 +18,7 @@ dependencies = [
     "python-dotenv>=1.0.1",
     "httpx>=0.27.0",
     "openinference-instrumentation-langchain>=0.1.56",
-    "jsonschema-pydantic-converter>=0.1.9",
+    "jsonschema-pydantic-converter>=0.2.0",
     "jsonpath-ng>=1.7.0",
     "mcp==1.26.0",
     "langchain-mcp-adapters==0.2.1",

src/uipath_langchain/_utils/__init__.py

@@ -1,3 +1,4 @@
+from ._environment import get_execution_folder_path
 from ._request_mixin import UiPathRequestMixin
 
-__all__ = ["UiPathRequestMixin"]
+__all__ = ["UiPathRequestMixin", "get_execution_folder_path"]

src/uipath_langchain/_utils/_environment.py

@@ -0,0 +1,6 @@
+import os
+
+
+def get_execution_folder_path() -> str | None:
+    """Reads the agent's executing folder path from the runtime environment."""
+    return os.environ.get("UIPATH_FOLDER_PATH")

src/uipath_langchain/_utils/_request_mixin.py

@@ -33,6 +33,7 @@
     get_uipath_token_header,
 )
 from uipath_langchain._utils._sleep_policy import before_sleep_log
+from uipath_langchain.chat.http_client import build_uipath_headers, resolve_gateway_url
 from uipath_langchain.runtime.errors import (
     LangGraphErrorCode,
     LangGraphRuntimeError,
@@ -78,8 +79,6 @@ class UiPathRequestMixin(BaseModel):
 
     default_headers: Mapping[str, str] | None = {
         "X-UiPath-Streaming-Enabled": "false",
-        "X-UiPath-JobKey": os.getenv("UIPATH_JOB_KEY", ""),
-        "X-UiPath-ProcessKey": os.getenv("UIPATH_PROCESS_KEY", ""),
     }
     model_name: str | None = Field(
         default_factory=lambda: os.getenv(
@@ -154,6 +153,7 @@ class UiPathRequestMixin(BaseModel):
     max_delay: float = 60.0
 
     _url: str | None = None
+    _is_override: bool = False
     _auth_headers: dict[str, str] | None = None
 
     # required to instantiate AzureChatOpenAI subclasses
@@ -731,17 +731,26 @@ def _prepare_url(self, url: str) -> httpx.URL:
     def _build_headers(self, options, retries_taken: int = 0) -> httpx.Headers:
         return httpx.Headers(self.auth_headers)
 
+    def _resolve_url_and_override(self) -> None:
+        """Resolve ``_url`` and ``_is_override`` idempotently."""
+        if self._url:
+            return
+        try:
+            self._url, self._is_override = resolve_gateway_url(self.endpoint)
+        except ValueError:
+            self._url = (
+                f"{self.base_url}/{self.org_id}/{self.tenant_id}/{self.endpoint}"
+            )
+        except NotImplementedError:
+            pass
+
     @property
     def url(self) -> str:
+        self._resolve_url_and_override()
         if not self._url:
-            env_uipath_url = os.getenv("UIPATH_URL")
-
-            if env_uipath_url:
-                self._url = f"{env_uipath_url.rstrip('/')}/{self.endpoint}"
-            else:
-                self._url = (
-                    f"{self.base_url}/{self.org_id}/{self.tenant_id}/{self.endpoint}"
-                )
+            raise NotImplementedError(
+                "The endpoint property is not implemented for this class."
+            )
         return self._url
 
     @property
@@ -753,17 +762,21 @@ def endpoint(self) -> str:
     @property
     def auth_headers(self) -> dict[str, str]:
         if not self._auth_headers:
+            self._resolve_url_and_override()
             self._auth_headers = {
                 **self.default_headers,  # type: ignore
-                "Authorization": f"Bearer {self.access_token}",
-                "X-UiPath-LlmGateway-TimeoutSeconds": str(self.default_request_timeout),
             }
-            if self.agenthub_config:
-                self._auth_headers["X-UiPath-AgentHub-Config"] = self.agenthub_config
-            if self.byo_connection_id:
-                self._auth_headers["X-UiPath-LlmGateway-ByoIsConnectionId"] = (
-                    self.byo_connection_id
+            self._auth_headers["Authorization"] = f"Bearer {self.access_token}"
+            self._auth_headers.update(
+                build_uipath_headers(
+                    agenthub_config=self.agenthub_config,
+                    byo_connection_id=self.byo_connection_id,
+                    inject_routing=self._is_override,
                 )
+            )
+            self._auth_headers["X-UiPath-LlmGateway-TimeoutSeconds"] = str(
+                self.default_request_timeout
+            )
             if self.is_normalized and self.model_name:
                 self._auth_headers["X-UiPath-LlmGateway-NormalizedApi-ModelName"] = (
                     self.model_name

src/uipath_langchain/agent/react/json_utils.py

@@ -2,7 +2,7 @@
 from typing import Any, ForwardRef, Union, get_args, get_origin
 
 from jsonpath_ng import parse  # type: ignore[import-untyped]
-from pydantic import BaseModel
+from pydantic import BaseModel, RootModel
 
 
 def get_json_paths_by_type(model: type[BaseModel], type_name: str) -> list[str]:
@@ -63,26 +63,35 @@ def _recursive_search(
                 continue
 
             if origin is list:
-                args = get_args(annotation)
-                if args:
-                    list_item_type = args[0]
-                    if matches_type(list_item_type):
-                        json_paths.append(f"{field_path}[*]")
-                        continue
-
-                    if _is_pydantic_model(list_item_type):
-                        nested_paths = _recursive_search(
-                            list_item_type, f"{field_path}[*]"
-                        )
-                        json_paths.extend(nested_paths)
-                        continue
+                inner_type, suffix = _unwrap_lists(annotation)
+                inner_path = f"{field_path}{suffix}"
+                if matches_type(inner_type):
+                    json_paths.append(inner_path)
+                    continue
+                if _is_pydantic_model(inner_type):
+                    nested_paths = _recursive_search(inner_type, inner_path)
+                    json_paths.extend(nested_paths)
+                    continue
 
             if _is_pydantic_model(annotation):
                 nested_paths = _recursive_search(annotation, field_path)
                 json_paths.extend(nested_paths)
 
         return json_paths
 
+    # RootModel serializes without the "root" wrapper — e.g. RootModel[list[X]]
+    # dumps as [...], not {"root": [...]}.  Iterating model_fields directly would
+    # produce wrong paths like "$.root.field".  Instead we peel off the RootModel
+    # envelope (and any Optional/list layers) so _recursive_search only ever sees
+    # a plain BaseModel with correct JSONPath prefixes (e.g. "$[*].field").
+    if issubclass(model, RootModel):
+        inner = _unwrap_optional(model.model_fields["root"].annotation)
+        inner, suffix = _unwrap_lists(inner)
+        # Primitive or non-model root types can't contain nested typed fields.
+        if not _is_pydantic_model(inner):
+            return []
+        return _recursive_search(inner, f"${suffix}" if suffix else "")
+
     return _recursive_search(model, "")
 
 
@@ -179,5 +188,21 @@ def _unwrap_optional(annotation: Any) -> Any:
     return annotation
 
 
+def _unwrap_lists(annotation: Any) -> tuple[Any, str]:
+    """Unwrap nested list types, returning (inner_type, jsonpath_suffix).
+
+    Each list layer adds a "[*]" wildcard so the resulting suffix maps directly
+    to JSONPath:  list[list[X]] → (X, "[*][*]").
+    """
+    suffix = ""
+    while get_origin(annotation) is list:
+        args = get_args(annotation)
+        if not args:
+            break
+        annotation = args[0]
+        suffix += "[*]"
+    return annotation, suffix
+
+
 def _is_pydantic_model(annotation: Any) -> bool:
     return isinstance(annotation, type) and issubclass(annotation, BaseModel)

src/uipath_langchain/agent/react/jsonschema_pydantic_converter.py

@@ -1,7 +1,7 @@
 import inspect
 import sys
 from types import ModuleType
-from typing import Any, Type, get_args, get_origin
+from typing import Any, Type
 
 from jsonschema_pydantic_converter import transform_with_modules
 from pydantic import BaseModel
@@ -37,53 +37,17 @@ def create_model(
         )
 
     model, namespace = transform_with_modules(schema)
-    corrected_namespace: dict[str, Any] = {}
-
-    def collect_types(annotation: Any) -> None:
-        """Recursively collect all BaseModel types from an annotation."""
-        # Unwrap generic types like List, Optional, etc.
-        origin = get_origin(annotation)
-        if origin is not None:
-            for arg in get_args(annotation):
-                collect_types(arg)
-
-        elif inspect.isclass(annotation) and issubclass(annotation, BaseModel):
-            # Find the original name for this type from the namespace
-            for type_name, type_def in namespace.items():
-                # Match by class name since rebuild may create new instances
-                if (
-                    hasattr(annotation, "__name__")
-                    and hasattr(type_def, "__name__")
-                    and annotation.__name__ == type_def.__name__
-                ):
-                    # Store the actual annotation type, not the old namespace one
-                    annotation.__name__ = type_name
-                    corrected_namespace[type_name] = annotation
-                    break
-
-    # Collect all types from field annotations
-    for field_info in model.model_fields.values():
-        collect_types(field_info.annotation)
-
-    # Get the shared pseudo-module and populate it with this schema's types
-    # This ensures that forward references can be resolved by get_type_hints()
-    # when the model is used with external libraries (e.g., LangGraph)
+
     pseudo_module = _get_or_create_dynamic_module()
 
-    # Populate the pseudo-module with all types from the namespace
-    # Use the original names so forward references resolve correctly
-    for type_name, type_def in corrected_namespace.items():
+    for type_name, type_def in namespace.items():
         setattr(pseudo_module, type_name, type_def)
+        if inspect.isclass(type_def) and issubclass(type_def, BaseModel):
+            type_def.__module__ = _DYNAMIC_MODULE_NAME
 
     setattr(pseudo_module, model.__name__, model)
-
-    # Update the model's __module__ to point to the shared pseudo-module
     model.__module__ = _DYNAMIC_MODULE_NAME
 
-    # Update the __module__ of all generated types in the namespace
-    for type_def in corrected_namespace.values():
-        if inspect.isclass(type_def) and issubclass(type_def, BaseModel):
-            type_def.__module__ = _DYNAMIC_MODULE_NAME
     return model
 
 

src/uipath_langchain/agent/tools/__init__.py

@@ -5,6 +5,7 @@
 from .extraction_tool import create_ixp_extraction_tool
 from .integration_tool import create_integration_tool
 from .ixp_escalation_tool import create_ixp_escalation_tool
+from .mcp import open_mcp_tools
 from .process_tool import create_process_tool
 from .tool_factory import (
     create_tools_from_resources,
@@ -15,6 +16,7 @@
     "create_tools_from_resources",
     "create_tool_node",
     "create_context_tool",
+    "open_mcp_tools",
     "create_process_tool",
     "create_integration_tool",
     "create_escalation_tool",