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

uipath_langchain/chat/bedrock.py

@@ -48,10 +48,14 @@ class AwsBedrockCompletionsPassthroughClient:
         model: str,
         token: str,
         api_flavor: str,
+        agenthub_config: Optional[str] = None,
+        byo_connection_id: Optional[str] = None,
     ):
         self.model = model
         self.token = token
         self.api_flavor = api_flavor
+        self.agenthub_config = agenthub_config
+        self.byo_connection_id = byo_connection_id
         self._vendor = "awsbedrock"
         self._url: Optional[str] = None
 
@@ -101,6 +105,10 @@ class AwsBedrockCompletionsPassthroughClient:
             "X-UiPath-Streaming-Enabled": streaming,
         }
 
+        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
         job_key = os.getenv("UIPATH_JOB_KEY")
         process_key = os.getenv("UIPATH_PROCESS_KEY")
         if job_key:
@@ -118,6 +126,8 @@ class UiPathChatBedrockConverse(ChatBedrockConverse):
         tenant_id: Optional[str] = None,
         token: Optional[str] = None,
         model_name: str = BedrockModels.anthropic_claude_haiku_4_5,
+        agenthub_config: Optional[str] = None,
+        byo_connection_id: Optional[str] = None,
         **kwargs,
     ):
         org_id = org_id or os.getenv("UIPATH_ORGANIZATION_ID")
@@ -141,6 +151,8 @@ class UiPathChatBedrockConverse(ChatBedrockConverse):
             model=model_name,
             token=token,
             api_flavor="converse",
+            agenthub_config=agenthub_config,
+            byo_connection_id=byo_connection_id,
         )
 
         client = passthrough_client.get_client()
@@ -156,6 +168,8 @@ class UiPathChatBedrock(ChatBedrock):
         tenant_id: Optional[str] = None,
         token: Optional[str] = None,
         model_name: str = BedrockModels.anthropic_claude_haiku_4_5,
+        agenthub_config: Optional[str] = None,
+        byo_connection_id: Optional[str] = None,
         **kwargs,
     ):
         org_id = org_id or os.getenv("UIPATH_ORGANIZATION_ID")
@@ -179,6 +193,8 @@ class UiPathChatBedrock(ChatBedrock):
             model=model_name,
             token=token,
             api_flavor="invoke",
+            agenthub_config=agenthub_config,
+            byo_connection_id=byo_connection_id,
         )
 
         client = passthrough_client.get_client()

uipath_langchain/chat/openai.py

@@ -4,6 +4,7 @@ from typing import Optional
 
 import httpx
 from langchain_openai import AzureChatOpenAI
+from uipath._utils._ssl_context import get_httpx_client_kwargs
 from uipath.utils import EndpointManager
 
 from .supported_models import OpenAIModels
@@ -11,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)
 
@@ -35,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)
 
@@ -57,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")
@@ -80,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),
-                verify=True,
+                transport=UiPathURLRewriteTransport(verify=verify),
+                **client_kwargs,
             ),
             http_client=httpx.Client(
-                transport=UiPathSyncURLRewriteTransport(verify=True),
-                verify=True,
+                transport=UiPathSyncURLRewriteTransport(verify=verify),
+                **client_kwargs,
             ),
             api_key=token,
             api_version=api_version,
@@ -104,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
@@ -116,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

@@ -0,0 +1,271 @@
+import os
+from typing import Any, Optional
+
+import httpx
+from uipath._utils._ssl_context import get_httpx_client_kwargs
+from uipath.utils import EndpointManager
+
+from .supported_models import GeminiModels
+
+
+def _check_genai_dependencies() -> None:
+    """Check if required dependencies for UiPathChatVertex are installed."""
+    import importlib.util
+
+    missing_packages = []
+
+    if importlib.util.find_spec("langchain_google_genai") is None:
+        missing_packages.append("langchain-google-genai")
+
+    if importlib.util.find_spec("google.genai") is None:
+        missing_packages.append("google-genai")
+
+    if missing_packages:
+        packages_str = ", ".join(missing_packages)
+        raise ImportError(
+            f"The following packages are required to use UiPathChatVertex: {packages_str}\n"
+            "Please install them using one of the following methods:\n\n"
+            "  # Using pip:\n"
+            f"  pip install uipath-langchain[vertex]\n\n"
+            "  # Using uv:\n"
+            f"  uv add 'uipath-langchain[vertex]'\n\n"
+        )
+
+
+_check_genai_dependencies()
+
+import google.genai
+from google.genai import types as genai_types
+from langchain_google_genai import ChatGoogleGenerativeAI
+from pydantic import PrivateAttr
+
+
+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.HTTPTransport):
+    """Transport that rewrites URLs to redirect to UiPath gateway."""
+
+    def __init__(self, gateway_url: str, verify: bool = True):
+        super().__init__(verify=verify)
+        self.gateway_url = gateway_url
+
+    def handle_request(self, request: httpx.Request) -> httpx.Response:
+        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.AsyncHTTPTransport):
+    """Async transport that rewrites URLs to redirect to UiPath gateway."""
+
+    def __init__(self, gateway_url: str, verify: bool = True):
+        super().__init__(verify=verify)
+        self.gateway_url = gateway_url
+
+    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+        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):
+    """UiPath Vertex AI Chat model that routes requests through UiPath's LLM Gateway."""
+
+    _vendor: str = PrivateAttr(default="vertexai")
+    _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,
+        org_id: Optional[str] = None,
+        tenant_id: Optional[str] = None,
+        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")
+        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"
+            )
+
+        uipath_url = self._build_base_url(model_name)
+        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, verify=verify),
+                headers=headers,
+                **client_kwargs,
+            ),
+            httpx_async_client=httpx.AsyncClient(
+                transport=_AsyncUrlRewriteTransport(uipath_url, verify=verify),
+                headers=headers,
+                **client_kwargs,
+            ),
+        )
+
+        if temperature is None and (
+            "gemini-3" in model_name or "gemini-2" in model_name
+        ):
+            temperature = 1.0
+
+        super().__init__(
+            model=model_name,
+            google_api_key="uipath-gateway",
+            temperature=temperature,
+            **kwargs,
+        )
+
+        custom_client = google.genai.Client(
+            api_key="uipath-gateway",
+            http_options=http_options,
+        )
+
+        object.__setattr__(self, "client", custom_client)
+
+        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]")
+
+        if self.top_p is not None and not 0 <= self.top_p <= 1:
+            raise ValueError("top_p must be in the range [0.0, 1.0]")
+
+        if self.top_k is not None and self.top_k <= 0:
+            raise ValueError("top_k must be positive")
+
+        additional_headers = self.additional_headers or {}
+        self.default_metadata = tuple(additional_headers.items())
+
+    @staticmethod
+    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"):
+            headers["X-UiPath-ProcessKey"] = process_key
+        return headers
+
+    @staticmethod
+    def _build_base_url(model_name: str) -> str:
+        """Build the full URL for the UiPath LLM Gateway."""
+        env_uipath_url = os.getenv("UIPATH_URL")
+
+        if not env_uipath_url:
+            raise ValueError("UIPATH_URL environment variable is required")
+
+        vendor_endpoint = EndpointManager.get_vendor_endpoint()
+        formatted_endpoint = vendor_endpoint.format(
+            vendor="vertexai",
+            model=model_name,
+        )
+        return f"{env_uipath_url.rstrip('/')}/{formatted_endpoint}"
+
+    def _stream(self, messages, stop=None, run_manager=None, **kwargs):
+        """Streaming fallback - calls _generate and yields single response."""
+        from langchain_core.messages import AIMessageChunk
+        from langchain_core.outputs import ChatGenerationChunk
+
+        result = self._generate(messages, stop=stop, run_manager=run_manager, **kwargs)
+
+        if result.generations:
+            message = result.generations[0].message
+            chunk = AIMessageChunk(
+                content=message.content,
+                additional_kwargs=message.additional_kwargs,
+                response_metadata=getattr(message, "response_metadata", {}),
+                id=message.id,
+                tool_calls=getattr(message, "tool_calls", []),
+                tool_call_chunks=getattr(message, "tool_call_chunks", []),
+            )
+            if hasattr(message, "usage_metadata") and message.usage_metadata:
+                chunk.usage_metadata = message.usage_metadata
+
+            yield ChatGenerationChunk(message=chunk)
+
+    async def _astream(self, messages, stop=None, run_manager=None, **kwargs):
+        """Async streaming fallback - calls _agenerate and yields single response."""
+        from langchain_core.messages import AIMessageChunk
+        from langchain_core.outputs import ChatGenerationChunk
+
+        result = await self._agenerate(
+            messages, stop=stop, run_manager=run_manager, **kwargs
+        )
+
+        if result.generations:
+            message = result.generations[0].message
+            chunk = AIMessageChunk(
+                content=message.content,
+                additional_kwargs=message.additional_kwargs,
+                response_metadata=getattr(message, "response_metadata", {}),
+                id=message.id,
+                tool_calls=getattr(message, "tool_calls", []),
+                tool_call_chunks=getattr(message, "tool_call_chunks", []),
+            )
+            if hasattr(message, "usage_metadata") and message.usage_metadata:
+                chunk.usage_metadata = message.usage_metadata
+
+            yield ChatGenerationChunk(message=chunk)

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