uipath-langchain 0.1.28__py3-none-any.whl → 0.3.1__py3-none-any.whl

uipath_langchain/chat/openai.py

@@ -12,21 +12,41 @@ from .supported_models import OpenAIModels
 logger = logging.getLogger(__name__)
 
 
+def _rewrite_openai_url(
+    original_url: str, params: httpx.QueryParams
+) -> httpx.URL | None:
+    """Rewrite OpenAI URLs to UiPath gateway completions endpoint.
+
+    Handles three URL patterns:
+    - responses: false -> .../openai/deployments/.../chat/completions?api-version=...
+    - responses: true  -> .../openai/responses?api-version=...
+    - responses API base -> .../{model}?api-version=... (no /openai/ path)
+
+    All are rewritten to .../completions
+    """
+    if "/openai/deployments/" in original_url:
+        base_url = original_url.split("/openai/deployments/")[0]
+    elif "/openai/responses" in original_url:
+        base_url = original_url.split("/openai/responses")[0]
+    else:
+        # Handle base URL case (no /openai/ path appended yet)
+        # Strip query string to get base URL
+        base_url = original_url.split("?")[0]
+
+    new_url_str = f"{base_url}/completions"
+    if params:
+        return httpx.URL(new_url_str, params=params)
+    return httpx.URL(new_url_str)
+
+
 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)
+        new_url = _rewrite_openai_url(str(request.url), request.url.params)
+        if new_url:
+            request.url = new_url
 
         return await super().handle_async_request(request)
 
@@ -36,16 +56,9 @@ class UiPathSyncURLRewriteTransport(httpx.HTTPTransport):
         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)
+        new_url = _rewrite_openai_url(str(request.url), request.url.params)
+        if new_url:
+            request.url = new_url
 
         return super().handle_request(request)
 
@@ -58,6 +71,9 @@ class UiPathChatOpenAI(AzureChatOpenAI):
         api_version: str = "2024-12-01-preview",
         org_id: Optional[str] = None,
         tenant_id: Optional[str] = None,
+        agenthub_config: Optional[str] = None,
+        extra_headers: Optional[dict[str, str]] = None,
+        byo_connection_id: Optional[str] = None,
         **kwargs,
     ):
         org_id = org_id or os.getenv("UIPATH_ORGANIZATION_ID")
@@ -81,18 +97,24 @@ class UiPathChatOpenAI(AzureChatOpenAI):
         self._vendor = "openai"
         self._model_name = model_name
         self._url: Optional[str] = None
+        self._agenthub_config = agenthub_config
+        self._byo_connection_id = byo_connection_id
+        self._extra_headers = extra_headers or {}
+
+        client_kwargs = get_httpx_client_kwargs()
+        verify = client_kwargs.get("verify", True)
 
         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),
-                **get_httpx_client_kwargs(),
+                transport=UiPathURLRewriteTransport(verify=verify),
+                **client_kwargs,
             ),
             http_client=httpx.Client(
-                transport=UiPathSyncURLRewriteTransport(verify=True),
-                **get_httpx_client_kwargs(),
+                transport=UiPathSyncURLRewriteTransport(verify=verify),
+                **client_kwargs,
             ),
             api_key=token,
             api_version=api_version,
@@ -105,10 +127,18 @@ class UiPathChatOpenAI(AzureChatOpenAI):
             "X-UiPath-LlmGateway-ApiFlavor": "auto",
             "Authorization": f"Bearer {token}",
         }
+
+        if self._agenthub_config:
+            headers["X-UiPath-AgentHub-Config"] = self._agenthub_config
+        if self._byo_connection_id:
+            headers["X-UiPath-LlmGateway-ByoIsConnectionId"] = self._byo_connection_id
         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
+
+        # Allow extra_headers to override defaults
+        headers.update(self._extra_headers)
         return headers
 
     @property
@@ -117,9 +147,9 @@ class UiPathChatOpenAI(AzureChatOpenAI):
         formatted_endpoint = vendor_endpoint.format(
             vendor=self._vendor,
             model=self._model_name,
-            api_version=self._openai_api_version,
         )
-        return formatted_endpoint.replace("/completions", "")
+        base_endpoint = formatted_endpoint.replace("/completions", "")
+        return f"{base_endpoint}?api-version={self._openai_api_version}"
 
     def _build_base_url(self) -> str:
         if not self._url:

uipath_langchain/chat/supported_models.py

@@ -21,14 +21,21 @@ class OpenAIModels:
     # GPT-5.1 models
     gpt_5_1_2025_11_13 = "gpt-5.1-2025-11-13"
 
+    # GPT-5.2 models
+    gpt_5_2_2025_12_11 = "gpt-5.2-2025-12-11"
+
 
 class GeminiModels:
     """Supported Google Gemini model identifiers."""
 
+    # Gemini 2 models
     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"
 
+    # Gemini 3 models
+    gemini_3_pro_preview = "gemini-3-pro-preview"
+
 
 class BedrockModels:
     """Supported AWS Bedrock model identifiers."""
@@ -38,5 +45,7 @@ class BedrockModels:
 
     # Claude 4 models
     anthropic_claude_sonnet_4 = "anthropic.claude-sonnet-4-20250514-v1:0"
+
+    # Claude 4.5 models
     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/chat/vertex.py

@@ -40,60 +40,59 @@ from langchain_google_genai import ChatGoogleGenerativeAI
 from pydantic import PrivateAttr
 
 
-def _rewrite_request_for_gateway(
-    request: httpx.Request, gateway_url: str
-) -> httpx.Request:
-    """Rewrite a request to redirect to the UiPath gateway."""
-    url_str = str(request.url)
-    if "generateContent" in url_str or "streamGenerateContent" in url_str:
-        is_streaming = "alt=sse" in url_str
-
-        headers = dict(request.headers)
-
-        headers["X-UiPath-Streaming-Enabled"] = "true" if is_streaming else "false"
-
-        gateway_url_parsed = httpx.URL(gateway_url)
-        if gateway_url_parsed.host:
-            headers["host"] = gateway_url_parsed.host
-
-        return httpx.Request(
-            method=request.method,
-            url=gateway_url,
-            headers=headers,
-            content=request.content,
-            extensions=request.extensions,
-        )
-    return request
+def _rewrite_vertex_url(original_url: str, gateway_url: str) -> httpx.URL | None:
+    """Rewrite Google GenAI URLs to UiPath gateway endpoint.
+
+    Handles URL patterns containing generateContent or streamGenerateContent.
+    Returns the gateway URL, or None if no rewrite needed.
+    """
+    if "generateContent" in original_url or "streamGenerateContent" in original_url:
+        return httpx.URL(gateway_url)
+    return None
 
 
-class _UrlRewriteTransport(httpx.BaseTransport):
+class _UrlRewriteTransport(httpx.HTTPTransport):
     """Transport that rewrites URLs to redirect to UiPath gateway."""
 
-    def __init__(self, gateway_url: str):
+    def __init__(self, gateway_url: str, verify: bool = True):
+        super().__init__(verify=verify)
         self.gateway_url = gateway_url
-        self._transport = httpx.HTTPTransport()
 
     def handle_request(self, request: httpx.Request) -> httpx.Response:
-        request = _rewrite_request_for_gateway(request, self.gateway_url)
-        return self._transport.handle_request(request)
-
-    def close(self) -> None:
-        self._transport.close()
+        original_url = str(request.url)
+        new_url = _rewrite_vertex_url(original_url, self.gateway_url)
+        if new_url:
+            # Set streaming header based on original URL before modifying
+            is_streaming = "alt=sse" in original_url
+            request.headers["X-UiPath-Streaming-Enabled"] = (
+                "true" if is_streaming else "false"
+            )
+            # Update host header to match the new URL
+            request.headers["host"] = new_url.host
+            request.url = new_url
+        return super().handle_request(request)
 
 
-class _AsyncUrlRewriteTransport(httpx.AsyncBaseTransport):
+class _AsyncUrlRewriteTransport(httpx.AsyncHTTPTransport):
     """Async transport that rewrites URLs to redirect to UiPath gateway."""
 
-    def __init__(self, gateway_url: str):
+    def __init__(self, gateway_url: str, verify: bool = True):
+        super().__init__(verify=verify)
         self.gateway_url = gateway_url
-        self._transport = httpx.AsyncHTTPTransport()
 
     async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
-        request = _rewrite_request_for_gateway(request, self.gateway_url)
-        return await self._transport.handle_async_request(request)
-
-    async def aclose(self) -> None:
-        await self._transport.aclose()
+        original_url = str(request.url)
+        new_url = _rewrite_vertex_url(original_url, self.gateway_url)
+        if new_url:
+            # Set streaming header based on original URL before modifying
+            is_streaming = "alt=sse" in original_url
+            request.headers["X-UiPath-Streaming-Enabled"] = (
+                "true" if is_streaming else "false"
+            )
+            # Update host header to match the new URL
+            request.headers["host"] = new_url.host
+            request.url = new_url
+        return await super().handle_async_request(request)
 
 
 class UiPathChatVertex(ChatGoogleGenerativeAI):
@@ -103,6 +102,8 @@ class UiPathChatVertex(ChatGoogleGenerativeAI):
     _model_name: str = PrivateAttr()
     _uipath_token: str = PrivateAttr()
     _uipath_llmgw_url: Optional[str] = PrivateAttr(default=None)
+    _agenthub_config: Optional[str] = PrivateAttr(default=None)
+    _byo_connection_id: Optional[str] = PrivateAttr(default=None)
 
     def __init__(
         self,
@@ -111,6 +112,8 @@ class UiPathChatVertex(ChatGoogleGenerativeAI):
         token: Optional[str] = None,
         model_name: str = GeminiModels.gemini_2_5_flash,
         temperature: Optional[float] = None,
+        agenthub_config: Optional[str] = None,
+        byo_connection_id: Optional[str] = None,
         **kwargs: Any,
     ):
         org_id = org_id or os.getenv("UIPATH_ORGANIZATION_ID")
@@ -131,18 +134,21 @@ class UiPathChatVertex(ChatGoogleGenerativeAI):
             )
 
         uipath_url = self._build_base_url(model_name)
-        headers = self._build_headers(token)
+        headers = self._build_headers(token, agenthub_config, byo_connection_id)
+
+        client_kwargs = get_httpx_client_kwargs()
+        verify = client_kwargs.get("verify", True)
 
         http_options = genai_types.HttpOptions(
             httpx_client=httpx.Client(
-                transport=_UrlRewriteTransport(uipath_url),
+                transport=_UrlRewriteTransport(uipath_url, verify=verify),
                 headers=headers,
-                **get_httpx_client_kwargs(),
+                **client_kwargs,
             ),
             httpx_async_client=httpx.AsyncClient(
-                transport=_AsyncUrlRewriteTransport(uipath_url),
+                transport=_AsyncUrlRewriteTransport(uipath_url, verify=verify),
                 headers=headers,
-                **get_httpx_client_kwargs(),
+                **client_kwargs,
             ),
         )
 
@@ -168,6 +174,8 @@ class UiPathChatVertex(ChatGoogleGenerativeAI):
         self._model_name = model_name
         self._uipath_token = token
         self._uipath_llmgw_url = uipath_url
+        self._agenthub_config = agenthub_config
+        self._byo_connection_id = byo_connection_id
 
         if self.temperature is not None and not 0 <= self.temperature <= 2.0:
             raise ValueError("temperature must be in the range [0.0, 2.0]")
@@ -182,11 +190,19 @@ class UiPathChatVertex(ChatGoogleGenerativeAI):
         self.default_metadata = tuple(additional_headers.items())
 
     @staticmethod
-    def _build_headers(token: str) -> dict[str, str]:
+    def _build_headers(
+        token: str,
+        agenthub_config: Optional[str] = None,
+        byo_connection_id: Optional[str] = None,
+    ) -> dict[str, str]:
         """Build HTTP headers for UiPath Gateway requests."""
         headers = {
             "Authorization": f"Bearer {token}",
         }
+        if agenthub_config:
+            headers["X-UiPath-AgentHub-Config"] = agenthub_config
+        if byo_connection_id:
+            headers["X-UiPath-LlmGateway-ByoIsConnectionId"] = byo_connection_id
         if job_key := os.getenv("UIPATH_JOB_KEY"):
             headers["X-UiPath-JobKey"] = job_key
         if process_key := os.getenv("UIPATH_PROCESS_KEY"):

uipath_langchain/embeddings/embeddings.py

@@ -4,6 +4,7 @@ from typing import Any
 import httpx
 from langchain_openai.embeddings import AzureOpenAIEmbeddings, OpenAIEmbeddings
 from pydantic import Field
+from uipath._utils._ssl_context import get_httpx_client_kwargs
 from uipath.utils import EndpointManager
 
 from uipath_langchain._utils._request_mixin import UiPathRequestMixin
@@ -26,19 +27,24 @@ class UiPathAzureOpenAIEmbeddings(UiPathRequestMixin, AzureOpenAIEmbeddings):
     )
 
     def __init__(self, **kwargs):
+        default_client_kwargs = get_httpx_client_kwargs()
+        client_kwargs = {
+            **default_client_kwargs,
+            "event_hooks": {
+                "request": [self._log_request_duration],
+                "response": [self._log_response_duration],
+            },
+        }
+        aclient_kwargs = {
+            **default_client_kwargs,
+            "event_hooks": {
+                "request": [self._alog_request_duration],
+                "response": [self._alog_response_duration],
+            },
+        }
         super().__init__(
-            http_client=httpx.Client(
-                event_hooks={
-                    "request": [self._log_request_duration],
-                    "response": [self._log_response_duration],
-                }
-            ),
-            http_async_client=httpx.AsyncClient(
-                event_hooks={
-                    "request": [self._alog_request_duration],
-                    "response": [self._alog_response_duration],
-                }
-            ),
+            http_client=httpx.Client(**client_kwargs),
+            http_async_client=httpx.AsyncClient(**aclient_kwargs),
             **kwargs,
         )
         # Monkey-patch the OpenAI client to use your custom methods

uipath_langchain/runtime/factory.py

@@ -92,7 +92,7 @@ class UiPathLangGraphRuntimeFactory:
         return self._config
 
     async def _load_graph(
-        self, entrypoint: str
+        self, entrypoint: str, **kwargs
     ) -> StateGraph[Any, Any, Any] | CompiledStateGraph[Any, Any, Any, Any]:
         """
         Load a graph for the given entrypoint.
@@ -181,7 +181,7 @@ class UiPathLangGraphRuntimeFactory:
         return builder.compile(checkpointer=memory)
 
     async def _resolve_and_compile_graph(
-        self, entrypoint: str, memory: AsyncSqliteSaver
+        self, entrypoint: str, memory: AsyncSqliteSaver, **kwargs
     ) -> CompiledStateGraph[Any, Any, Any, Any]:
         """
         Resolve a graph from configuration and compile it.
@@ -201,7 +201,7 @@ class UiPathLangGraphRuntimeFactory:
             if entrypoint in self._graph_cache:
                 return self._graph_cache[entrypoint]
 
-            loaded_graph = await self._load_graph(entrypoint)
+            loaded_graph = await self._load_graph(entrypoint, **kwargs)
 
             compiled_graph = await self._compile_graph(loaded_graph, memory)
 
@@ -249,6 +249,7 @@ class UiPathLangGraphRuntimeFactory:
         compiled_graph: CompiledStateGraph[Any, Any, Any, Any],
         runtime_id: str,
         entrypoint: str,
+        **kwargs,
     ) -> UiPathRuntimeProtocol:
         """
         Create a runtime instance from a compiled graph.
@@ -275,10 +276,11 @@ class UiPathLangGraphRuntimeFactory:
             delegate=base_runtime,
             storage=storage,
             trigger_manager=trigger_manager,
+            runtime_id=runtime_id,
         )
 
     async def new_runtime(
-        self, entrypoint: str, runtime_id: str
+        self, entrypoint: str, runtime_id: str, **kwargs
     ) -> UiPathRuntimeProtocol:
         """
         Create a new LangGraph runtime instance.
@@ -293,12 +295,15 @@ class UiPathLangGraphRuntimeFactory:
         # Get shared memory instance
         memory = await self._get_memory()
 
-        compiled_graph = await self._resolve_and_compile_graph(entrypoint, memory)
+        compiled_graph = await self._resolve_and_compile_graph(
+            entrypoint, memory, **kwargs
+        )
 
         return await self._create_runtime_instance(
             compiled_graph=compiled_graph,
             runtime_id=runtime_id,
             entrypoint=entrypoint,
+            **kwargs,
         )
 
     async def dispose(self) -> None:

uipath_langchain/runtime/runtime.py

@@ -3,6 +3,7 @@ import os
 from typing import Any, AsyncGenerator
 from uuid import uuid4
 
+from langchain_core.callbacks import BaseCallbackHandler
 from langchain_core.runnables.config import RunnableConfig
 from langgraph.errors import EmptyInputError, GraphRecursionError, InvalidUpdateError
 from langgraph.graph.state import CompiledStateGraph
@@ -41,6 +42,7 @@ class UiPathLangGraphRuntime:
         graph: CompiledStateGraph[Any, Any, Any, Any],
         runtime_id: str | None = None,
         entrypoint: str | None = None,
+        callbacks: list[BaseCallbackHandler] | None = None,
     ):
         """
         Initialize the runtime.
@@ -53,6 +55,7 @@ class UiPathLangGraphRuntime:
         self.graph: CompiledStateGraph[Any, Any, Any, Any] = graph
         self.runtime_id: str = runtime_id or "default"
         self.entrypoint: str | None = entrypoint
+        self.callbacks: list[BaseCallbackHandler] = callbacks or []
         self.chat = UiPathChatMessagesMapper()
         self._middleware_node_names: set[str] = self._detect_middleware_nodes()
 
@@ -135,10 +138,17 @@ class UiPathLangGraphRuntime:
                 if chunk_type == "messages":
                     if isinstance(data, tuple):
                         message, _ = data
-                        event = UiPathRuntimeMessageEvent(
-                            payload=self.chat.map_event(message),
-                        )
-                        yield event
+                        try:
+                            events = self.chat.map_event(message)
+                        except Exception as e:
+                            logger.warning(f"Error mapping message event: {e}")
+                            events = None
+                        if events:
+                            for mapped_event in events:
+                                event = UiPathRuntimeMessageEvent(
+                                    payload=mapped_event,
+                                )
+                                yield event
 
                 # Emit UiPathRuntimeStateEvent for state updates
                 elif chunk_type == "updates":
@@ -153,6 +163,8 @@ class UiPathLangGraphRuntime:
 
                         # Emit state update event for each node
                         for node_name, agent_data in data.items():
+                            if node_name in ("__metadata__",):
+                                continue
                             if isinstance(agent_data, dict):
                                 state_event = UiPathRuntimeStateEvent(
                                     payload=serialize_output(agent_data),
@@ -189,7 +201,7 @@ class UiPathLangGraphRuntime:
         """Build graph execution configuration."""
         graph_config: RunnableConfig = {
             "configurable": {"thread_id": self.runtime_id},
-            "callbacks": [],
+            "callbacks": self.callbacks,
         }
 
         # Add optional config from environment
@@ -283,29 +295,9 @@ class UiPathLangGraphRuntime:
 
     def _is_interrupted(self, state: StateSnapshot) -> bool:
         """Check if execution was interrupted (static or dynamic)."""
-        # Check for static interrupts (interrupt_before/after)
-        if hasattr(state, "next") and state.next:
-            return True
-
-        # Check for dynamic interrupts (interrupt() inside node)
-        if hasattr(state, "tasks"):
-            for task in state.tasks:
-                if hasattr(task, "interrupts") and task.interrupts:
-                    return True
-
-        return False
-
-    def _get_dynamic_interrupt(self, state: StateSnapshot) -> Interrupt | None:
-        """Get the first dynamic interrupt if any."""
-        if not hasattr(state, "tasks"):
-            return None
-
-        for task in state.tasks:
-            if hasattr(task, "interrupts") and task.interrupts:
-                for interrupt in task.interrupts:
-                    if isinstance(interrupt, Interrupt):
-                        return interrupt
-        return None
+        # An execution is considered interrupted if there are any next nodes (static interrupt)
+        # or if there are any dynamic interrupts present
+        return bool(state.next) or bool(state.interrupts)
 
     async def _create_runtime_result(
         self,
@@ -334,13 +326,24 @@ class UiPathLangGraphRuntime:
         graph_state: StateSnapshot,
     ) -> UiPathRuntimeResult:
         """Create result for suspended execution."""
-        # Check if it's a dynamic interrupt
-        dynamic_interrupt = self._get_dynamic_interrupt(graph_state)
-
-        if dynamic_interrupt:
-            # Dynamic interrupt - should create and save resume trigger
+        interrupt_map: dict[str, Any] = {}
+
+        if graph_state.interrupts:
+            for interrupt in graph_state.interrupts:
+                if isinstance(interrupt, Interrupt):
+                    # Find which task this interrupt belongs to
+                    for task in graph_state.tasks:
+                        if task.interrupts and interrupt in task.interrupts:
+                            # Only include if this task is still waiting for interrupt resolution
+                            if task.interrupts and not task.result:
+                                interrupt_map[interrupt.id] = interrupt.value
+                            break
+
+        # If we have dynamic interrupts, return suspended with interrupt map
+        # The output is used to create the resume triggers
+        if interrupt_map:
             return UiPathRuntimeResult(
-                output=dynamic_interrupt.value,
+                output=interrupt_map,
                 status=UiPathRuntimeStatus.SUSPENDED,
             )
         else:
@@ -360,7 +363,7 @@ class UiPathLangGraphRuntime:
         if next_nodes:
             # Breakpoint is BEFORE these nodes (interrupt_before)
             breakpoint_type = "before"
-            breakpoint_node = next_nodes[0]
+            breakpoint_node = ", ".join(next_nodes)
         else:
             # Breakpoint is AFTER the last executed node (interrupt_after)
             # Get the last executed node from tasks