uipath-langchain 0.0.133__py3-none-any.whl → 0.1.24__py3-none-any.whl

uipath_langchain/chat/openai.py

@@ -0,0 +1,132 @@
+import logging
+import os
+from typing import Optional
+
+import httpx
+from langchain_openai import AzureChatOpenAI
+from uipath.utils import EndpointManager
+
+from .supported_models import OpenAIModels
+
+logger = logging.getLogger(__name__)
+
+
+class UiPathURLRewriteTransport(httpx.AsyncHTTPTransport):
+    def __init__(self, verify: bool = True, **kwargs):
+        super().__init__(verify=verify, **kwargs)
+
+    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+        original_url = str(request.url)
+
+        if "/openai/deployments/" in original_url:
+            base_url = original_url.split("/openai/deployments/")[0]
+            query_string = request.url.params
+            new_url_str = f"{base_url}/completions"
+            if query_string:
+                request.url = httpx.URL(new_url_str, params=query_string)
+            else:
+                request.url = httpx.URL(new_url_str)
+
+        return await super().handle_async_request(request)
+
+
+class UiPathSyncURLRewriteTransport(httpx.HTTPTransport):
+    def __init__(self, verify: bool = True, **kwargs):
+        super().__init__(verify=verify, **kwargs)
+
+    def handle_request(self, request: httpx.Request) -> httpx.Response:
+        original_url = str(request.url)
+
+        if "/openai/deployments/" in original_url:
+            base_url = original_url.split("/openai/deployments/")[0]
+            query_string = request.url.params
+            new_url_str = f"{base_url}/completions"
+            if query_string:
+                request.url = httpx.URL(new_url_str, params=query_string)
+            else:
+                request.url = httpx.URL(new_url_str)
+
+        return super().handle_request(request)
+
+
+class UiPathChatOpenAI(AzureChatOpenAI):
+    def __init__(
+        self,
+        token: Optional[str] = None,
+        model_name: str = OpenAIModels.gpt_5_mini_2025_08_07,
+        api_version: str = "2024-12-01-preview",
+        org_id: Optional[str] = None,
+        tenant_id: Optional[str] = None,
+        **kwargs,
+    ):
+        org_id = org_id or os.getenv("UIPATH_ORGANIZATION_ID")
+        tenant_id = tenant_id or os.getenv("UIPATH_TENANT_ID")
+        token = token or os.getenv("UIPATH_ACCESS_TOKEN")
+
+        if not org_id:
+            raise ValueError(
+                "UIPATH_ORGANIZATION_ID environment variable or org_id parameter is required"
+            )
+        if not tenant_id:
+            raise ValueError(
+                "UIPATH_TENANT_ID environment variable or tenant_id parameter is required"
+            )
+        if not token:
+            raise ValueError(
+                "UIPATH_ACCESS_TOKEN environment variable or token parameter is required"
+            )
+
+        self._openai_api_version = api_version
+        self._vendor = "openai"
+        self._model_name = model_name
+        self._url: Optional[str] = None
+
+        super().__init__(
+            azure_endpoint=self._build_base_url(),
+            model_name=model_name,
+            default_headers=self._build_headers(token),
+            http_async_client=httpx.AsyncClient(
+                transport=UiPathURLRewriteTransport(verify=True),
+                verify=True,
+            ),
+            http_client=httpx.Client(
+                transport=UiPathSyncURLRewriteTransport(verify=True),
+                verify=True,
+            ),
+            api_key=token,
+            api_version=api_version,
+            validate_base_url=False,
+            **kwargs,
+        )
+
+    def _build_headers(self, token: str) -> dict[str, str]:
+        headers = {
+            "X-UiPath-LlmGateway-ApiFlavor": "auto",
+            "Authorization": f"Bearer {token}",
+        }
+        if job_key := os.getenv("UIPATH_JOB_KEY"):
+            headers["X-UiPath-JobKey"] = job_key
+        if process_key := os.getenv("UIPATH_PROCESS_KEY"):
+            headers["X-UiPath-ProcessKey"] = process_key
+        return headers
+
+    @property
+    def endpoint(self) -> str:
+        vendor_endpoint = EndpointManager.get_vendor_endpoint()
+        formatted_endpoint = vendor_endpoint.format(
+            vendor=self._vendor,
+            model=self._model_name,
+            api_version=self._openai_api_version,
+        )
+        return formatted_endpoint.replace("/completions", "")
+
+    def _build_base_url(self) -> str:
+        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:
+                raise ValueError("UIPATH_URL environment variable is required")
+
+        return self._url

uipath_langchain/chat/supported_models.py

@@ -0,0 +1,42 @@
+class OpenAIModels:
+    """Supported OpenAI model identifiers."""
+
+    # GPT-4o models
+    gpt_4o_2024_05_13 = "gpt-4o-2024-05-13"
+    gpt_4o_2024_08_06 = "gpt-4o-2024-08-06"
+    gpt_4o_2024_11_20 = "gpt-4o-2024-11-20"
+    gpt_4o_mini_2024_07_18 = "gpt-4o-mini-2024-07-18"
+
+    # GPT-4.1 models
+    gpt_4_1_2025_04_14 = "gpt-4.1-2025-04-14"
+    gpt_4_1_mini_2025_04_14 = "gpt-4.1-mini-2025-04-14"
+    gpt_4_1_nano_2025_04_14 = "gpt-4.1-nano-2025-04-14"
+
+    # GPT-5 models
+    gpt_5_2025_08_07 = "gpt-5-2025-08-07"
+    gpt_5_chat_2025_08_07 = "gpt-5-chat-2025-08-07"
+    gpt_5_mini_2025_08_07 = "gpt-5-mini-2025-08-07"
+    gpt_5_nano_2025_08_07 = "gpt-5-nano-2025-08-07"
+
+    # GPT-5.1 models
+    gpt_5_1_2025_11_13 = "gpt-5.1-2025-11-13"
+
+
+class GeminiModels:
+    """Supported Google Gemini model identifiers."""
+
+    gemini_2_5_pro = "gemini-2.5-pro"
+    gemini_2_5_flash = "gemini-2.5-flash"
+    gemini_2_0_flash_001 = "gemini-2.0-flash-001"
+
+
+class BedrockModels:
+    """Supported AWS Bedrock model identifiers."""
+
+    # Claude 3.7 models
+    anthropic_claude_3_7_sonnet = "anthropic.claude-3-7-sonnet-20250219-v1:0"
+
+    # Claude 4 models
+    anthropic_claude_sonnet_4 = "anthropic.claude-sonnet-4-20250514-v1:0"
+    anthropic_claude_sonnet_4_5 = "anthropic.claude-sonnet-4-5-20250929-v1:0"
+    anthropic_claude_haiku_4_5 = "anthropic.claude-haiku-4-5-20251001-v1:0"

uipath_langchain/embeddings/embeddings.py

@@ -1,8 +1,7 @@
 import os
-from typing import List, Optional
+from typing import Any
 
 import httpx
-from langchain_community.callbacks.manager import openai_callback_var
 from langchain_openai.embeddings import AzureOpenAIEmbeddings, OpenAIEmbeddings
 from pydantic import Field
 from uipath.utils import EndpointManager
@@ -11,9 +10,15 @@ from uipath_langchain._utils._request_mixin import UiPathRequestMixin
 
 
 class UiPathAzureOpenAIEmbeddings(UiPathRequestMixin, AzureOpenAIEmbeddings):
-    """Custom Embeddings connector for LangChain integration with UiPath, with minimal changes compared to AzureOpenAIEmbeddings."""
+    """Custom Embeddings connector for LangChain integration with UiPath.
 
-    model_name: Optional[str] = Field(
+    This class modifies the OpenAI client to:
+    - Use UiPath endpoints
+    - Log request/response durations
+    - Apply custom URL preparation and header building
+    """
+
+    model_name: str | None = Field(
         default_factory=lambda: os.getenv(
             "UIPATH_MODEL_NAME", "text-embedding-3-large"
         ),
@@ -36,6 +41,7 @@ class UiPathAzureOpenAIEmbeddings(UiPathRequestMixin, AzureOpenAIEmbeddings):
             ),
             **kwargs,
         )
+        # Monkey-patch the OpenAI client to use your custom methods
         self.client._client._prepare_url = self._prepare_url
         self.client._client._build_headers = self._build_headers
         self.async_client._client._prepare_url = self._prepare_url
@@ -50,63 +56,154 @@ class UiPathAzureOpenAIEmbeddings(UiPathRequestMixin, AzureOpenAIEmbeddings):
 
 
 class UiPathOpenAIEmbeddings(UiPathRequestMixin, OpenAIEmbeddings):
-    """Custom Embeddings connector for LangChain integration with UiPath, with full control over the embedding call."""
+    """Custom Embeddings connector for LangChain integration with UiPath.
+
+    This implementation uses custom _call and _acall methods for full control
+    over the API request/response cycle.
+    """
 
-    model_name: Optional[str] = Field(
+    model_name: str | None = Field(
         default_factory=lambda: os.getenv(
             "UIPATH_MODEL_NAME", "text-embedding-3-large"
         ),
         alias="model",
     )
 
+    # Add instance variables for tracking if needed
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._total_tokens = 0
+        self._total_requests = 0
+
     def embed_documents(
-        self, texts: List[str], chunk_size: Optional[int] = None, **kwargs
-    ) -> List[List[float]]:
-        """Embed a list of documents using the UiPath."""
-        embeddings = []
-        total_tokens = 0
-        # Process in chunks if specified
-        chunk_size_ = chunk_size or self.chunk_size or len(texts)
+        self, texts: list[str], chunk_size: int | None = None, **kwargs: Any
+    ) -> list[list[float]]:
+        """Embed a list of documents using UiPath endpoint.
+
+        Args:
+            texts: List of texts to embed
+            chunk_size: Number of texts to process in each batch
+            **kwargs: Additional arguments passed to the API
+
+        Returns:
+            List of embeddings for each text
+        """
+        chunk_size_ = chunk_size or self.chunk_size
+        embeddings: list[list[float]] = []
+
         for i in range(0, len(texts), chunk_size_):
             chunk = texts[i : i + chunk_size_]
-            payload = {"input": chunk}
+
+            # Build payload matching OpenAI API format
+            payload: dict[str, Any] = {
+                "input": chunk,
+                "model": self.model,
+            }
+
+            # Add optional parameters
+            if self.dimensions is not None:
+                payload["dimensions"] = self.dimensions
+
+            # Add model_kwargs and any additional kwargs
+            payload.update(self.model_kwargs)
+            payload.update(kwargs)
+
+            # Make the API call using custom _call method
             response = self._call(self.url, payload, self.auth_headers)
+
+            # Extract embeddings
             chunk_embeddings = [r["embedding"] for r in response["data"]]
-            total_tokens += response["usage"]["prompt_tokens"]
             embeddings.extend(chunk_embeddings)
-        if contextvar := openai_callback_var.get():
-            contextvar.prompt_tokens += total_tokens
-            contextvar.total_tokens += total_tokens
-            contextvar.successful_requests += 1
+
+            # Track usage internally (optional)
+            if "usage" in response:
+                self._total_tokens += response["usage"].get("total_tokens", 0)
+                self._total_requests += 1
+
         return embeddings
 
     async def aembed_documents(
         self,
-        texts: List[str],
-        chunk_size: Optional[int] = None,
-        **kwargs,
-    ) -> List[List[float]]:
-        """Async version of embed_documents."""
-        embeddings = []
-        total_tokens = 0
-        # Process in chunks if specified
-        chunk_size_ = chunk_size or self.chunk_size or len(texts)
+        texts: list[str],
+        chunk_size: int | None = None,
+        **kwargs: Any,
+    ) -> list[list[float]]:
+        """Async version of embed_documents.
+
+        Args:
+            texts: List of texts to embed
+            chunk_size: Number of texts to process in each batch
+            **kwargs: Additional arguments passed to the API
+
+        Returns:
+            List of embeddings for each text
+        """
+        chunk_size_ = chunk_size or self.chunk_size
+        embeddings: list[list[float]] = []
+
         for i in range(0, len(texts), chunk_size_):
             chunk = texts[i : i + chunk_size_]
-            payload = {"input": chunk}
+
+            # Build payload matching OpenAI API format
+            payload: dict[str, Any] = {
+                "input": chunk,
+                "model": self.model,
+            }
+
+            # Add optional parameters
+            if self.dimensions is not None:
+                payload["dimensions"] = self.dimensions
+
+            # Add model_kwargs and any additional kwargs
+            payload.update(self.model_kwargs)
+            payload.update(kwargs)
+
+            # Make the async API call using custom _acall method
             response = await self._acall(self.url, payload, self.auth_headers)
+
+            # Extract embeddings
             chunk_embeddings = [r["embedding"] for r in response["data"]]
-            total_tokens += response["usage"]["prompt_tokens"]
             embeddings.extend(chunk_embeddings)
-        if contextvar := openai_callback_var.get():
-            contextvar.prompt_tokens += total_tokens
-            contextvar.total_tokens += total_tokens
-            contextvar.successful_requests += 1
+
+            # Track usage internally (optional)
+            if "usage" in response:
+                self._total_tokens += response["usage"].get("total_tokens", 0)
+                self._total_requests += 1
+
         return embeddings
 
     @property
     def endpoint(self) -> str:
+        """Get the UiPath endpoint for embeddings."""
         endpoint = EndpointManager.get_embeddings_endpoint()
         return endpoint.format(
             model=self.model_name, api_version=self.openai_api_version
         )
+
+    @property
+    def url(self) -> str:
+        """Get the full URL for API requests."""
+        return self.endpoint
+
+    @property
+    def auth_headers(self) -> dict[str, str]:
+        """Get authentication headers for API requests."""
+        headers = {}
+        if self.openai_api_key:
+            headers["Authorization"] = (
+                f"Bearer {self.openai_api_key.get_secret_value()}"
+            )
+        if self.default_headers:
+            headers.update(self.default_headers)
+        return headers
+
+    def get_usage_stats(self) -> dict[str, int]:
+        """Get token usage statistics.
+
+        Returns:
+            Dictionary with total_tokens and total_requests
+        """
+        return {
+            "total_tokens": self._total_tokens,
+            "total_requests": self._total_requests,
+        }

uipath_langchain/middlewares.py

@@ -1,16 +1,10 @@
 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
 
 
 def register_middleware():
     """This function will be called by the entry point system when uipath_langchain is installed"""
     Middlewares.register("init", langgraph_init_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/retrievers/context_grounding_retriever.py

@@ -1,24 +1,22 @@
-from typing import List, Optional
-
 from langchain_core.callbacks import (
     AsyncCallbackManagerForRetrieverRun,
     CallbackManagerForRetrieverRun,
 )
 from langchain_core.documents import Document
 from langchain_core.retrievers import BaseRetriever
-from uipath import UiPath
+from uipath.platform import UiPath
 
 
 class ContextGroundingRetriever(BaseRetriever):
     index_name: str
-    folder_path: Optional[str] = None
-    folder_key: Optional[str] = None
-    uipath_sdk: Optional[UiPath] = None
-    number_of_results: Optional[int] = 10
+    folder_path: str | None = None
+    folder_key: str | None = None
+    uipath_sdk: UiPath | None = None
+    number_of_results: int | None = 10
 
     def _get_relevant_documents(
         self, query: str, *, run_manager: CallbackManagerForRetrieverRun
-    ) -> List[Document]:
+    ) -> list[Document]:
         """Sync implementations for retriever calls context_grounding API to search the requested index."""
 
         sdk = self.uipath_sdk if self.uipath_sdk is not None else UiPath()
@@ -43,7 +41,7 @@ class ContextGroundingRetriever(BaseRetriever):
 
     async def _aget_relevant_documents(
         self, query: str, *, run_manager: AsyncCallbackManagerForRetrieverRun
-    ) -> List[Document]:
+    ) -> list[Document]:
         """Async implementations for retriever calls context_grounding API to search the requested index."""
 
         sdk = self.uipath_sdk if self.uipath_sdk is not None else UiPath()

uipath_langchain/runtime/__init__.py

@@ -0,0 +1,36 @@
+from uipath.runtime import (
+    UiPathRuntimeContext,
+    UiPathRuntimeFactoryProtocol,
+    UiPathRuntimeFactoryRegistry,
+)
+
+from uipath_langchain.runtime.factory import UiPathLangGraphRuntimeFactory
+from uipath_langchain.runtime.runtime import UiPathLangGraphRuntime
+from uipath_langchain.runtime.schema import (
+    get_entrypoints_schema,
+    get_graph_schema,
+)
+
+
+def register_runtime_factory() -> None:
+    """Register the LangGraph factory. Called automatically via entry point."""
+
+    def create_factory(
+        context: UiPathRuntimeContext | None = None,
+    ) -> UiPathRuntimeFactoryProtocol:
+        return UiPathLangGraphRuntimeFactory(
+            context=context if context else UiPathRuntimeContext(),
+        )
+
+    UiPathRuntimeFactoryRegistry.register("langgraph", create_factory, "langgraph.json")
+
+
+register_runtime_factory()
+
+__all__ = [
+    "register_runtime_factory",
+    "get_entrypoints_schema",
+    "get_graph_schema",
+    "UiPathLangGraphRuntimeFactory",
+    "UiPathLangGraphRuntime",
+]

uipath_langchain/runtime/_serialize.py

@@ -0,0 +1,46 @@
+from enum import Enum
+from typing import Any
+
+
+def serialize_output(output: Any) -> Any:
+    """
+    Recursively serialize an output object.
+
+    Args:
+        output: The object to serialize
+
+    Returns:
+        Dict[str, Any]: Serialized output as dictionary
+    """
+    if output is None:
+        return {}
+
+    # Handle Pydantic models
+    if hasattr(output, "model_dump"):
+        return serialize_output(output.model_dump(by_alias=True))
+    elif hasattr(output, "dict"):
+        return serialize_output(output.dict())
+    elif hasattr(output, "to_dict"):
+        return serialize_output(output.to_dict())
+
+    # Handle dictionaries
+    elif isinstance(output, dict):
+        return {k: serialize_output(v) for k, v in output.items()}
+
+    # Handle lists
+    elif isinstance(output, list):
+        return [serialize_output(item) for item in output]
+
+    # Handle other iterables (convert to dict first)
+    elif hasattr(output, "__iter__") and not isinstance(output, (str, bytes)):
+        try:
+            return serialize_output(dict(output))
+        except (TypeError, ValueError):
+            return output
+
+    # Handle Enums
+    elif isinstance(output, Enum):
+        return output.value
+
+    # Return primitive types as is
+    return output

uipath_langchain/runtime/config.py

@@ -0,0 +1,61 @@
+"""Simple loader for langgraph.json configuration."""
+
+import json
+import os
+
+
+class LangGraphConfig:
+    """Simple loader for langgraph.json configuration."""
+
+    def __init__(self, config_path: str = "langgraph.json"):
+        """
+        Initialize configuration loader.
+
+        Args:
+            config_path: Path to langgraph.json file
+        """
+        self.config_path = config_path
+        self._graphs: dict[str, str] | None = None
+
+    @property
+    def exists(self) -> bool:
+        """Check if langgraph.json exists."""
+        return os.path.exists(self.config_path)
+
+    @property
+    def graphs(self) -> dict[str, str]:
+        """
+        Get graph name -> path mapping from config.
+
+        Returns:
+            Dictionary mapping graph names to file paths (e.g., {"agent": "agent.py:graph"})
+        """
+        if self._graphs is None:
+            self._graphs = self._load_graphs()
+        return self._graphs
+
+    def _load_graphs(self) -> dict[str, str]:
+        """Load graph definitions from langgraph.json."""
+        if not self.exists:
+            raise FileNotFoundError(f"Config file not found: {self.config_path}")
+
+        try:
+            with open(self.config_path, "r") as f:
+                config = json.load(f)
+
+            if "graphs" not in config:
+                raise ValueError("Missing required 'graphs' field in langgraph.json")
+
+            graphs = config["graphs"]
+            if not isinstance(graphs, dict):
+                raise ValueError("'graphs' must be a dictionary")
+
+            return graphs
+
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON in {self.config_path}: {e}") from e
+
+    @property
+    def entrypoints(self) -> list[str]:
+        """Get list of available graph entrypoints."""
+        return list(self.graphs.keys())

uipath_langchain/runtime/errors.py

@@ -0,0 +1,43 @@
+from enum import Enum
+from typing import Union
+
+from uipath.runtime.errors import (
+    UiPathBaseRuntimeError,
+    UiPathErrorCategory,
+    UiPathErrorCode,
+)
+
+
+class LangGraphErrorCode(Enum):
+    CONFIG_MISSING = "CONFIG_MISSING"
+    CONFIG_INVALID = "CONFIG_INVALID"
+
+    GRAPH_NOT_FOUND = "GRAPH_NOT_FOUND"
+    GRAPH_IMPORT_ERROR = "GRAPH_IMPORT_ERROR"
+    GRAPH_TYPE_ERROR = "GRAPH_TYPE_ERROR"
+    GRAPH_VALUE_ERROR = "GRAPH_VALUE_ERROR"
+    GRAPH_LOAD_ERROR = "GRAPH_LOAD_ERROR"
+    GRAPH_INVALID_UPDATE = "GRAPH_INVALID_UPDATE"
+    GRAPH_EMPTY_INPUT = "GRAPH_EMPTY_INPUT"
+
+    DB_QUERY_FAILED = "DB_QUERY_FAILED"
+    DB_TABLE_CREATION_FAILED = "DB_TABLE_CREATION_FAILED"
+    HITL_EVENT_CREATION_FAILED = "HITL_EVENT_CREATION_FAILED"
+    DB_INSERT_FAILED = "DB_INSERT_FAILED"
+    LICENSE_NOT_AVAILABLE = "LICENSE_NOT_AVAILABLE"
+
+
+class LangGraphRuntimeError(UiPathBaseRuntimeError):
+    """Custom exception for LangGraph runtime errors with structured error information."""
+
+    def __init__(
+        self,
+        code: Union[LangGraphErrorCode, UiPathErrorCode],
+        title: str,
+        detail: str,
+        category: UiPathErrorCategory = UiPathErrorCategory.UNKNOWN,
+        status: int | None = None,
+    ):
+        super().__init__(
+            code.value, title, detail, category, status, prefix="LANGGRAPH"
+        )