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

uipath_langchain/embeddings/embeddings.py

@@ -1,19 +1,24 @@
 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
 
 from uipath_langchain._utils._request_mixin import UiPathRequestMixin
-from uipath_langchain._utils._settings import UiPathEndpoints
 
 
 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
@@ -43,67 +49,161 @@ class UiPathAzureOpenAIEmbeddings(UiPathRequestMixin, AzureOpenAIEmbeddings):
 
     @property
     def endpoint(self) -> str:
-        return UiPathEndpoints.EMBEDDING_ENDPOINT.value.format(
+        endpoint = EndpointManager.get_embeddings_endpoint()
+        return endpoint.format(
             model=self.model_name, api_version=self.openai_api_version
         )
 
 
 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
-    ) -> 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,
-    ) -> 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:
-        return UiPathEndpoints.EMBEDDING_ENDPOINT.value.format(
+        """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

@@ -2,11 +2,9 @@ from uipath._cli.middlewares import Middlewares
 
 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)

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"
+        )