uipath-langchain-client 1.0.0__py3-none-any.whl

uipath_langchain_client/clients/bedrock/embeddings.py

@@ -0,0 +1,33 @@
+from typing import Self
+
+from pydantic import model_validator
+from uipath_langchain_client.base_client import UiPathBaseLLMClient
+from uipath_langchain_client.settings import UiPathAPIConfig
+
+try:
+    from langchain_aws.embeddings import BedrockEmbeddings
+    from uipath_langchain_client.clients.bedrock.utils import WrappedBotoClient
+except ImportError as e:
+    raise ImportError(
+        "The 'aws' extra is required to use UiPathBedrockEmbeddings. "
+        "Install it with: uv add uipath-langchain-client[aws]"
+    ) from e
+
+
+class UiPathBedrockEmbeddings(UiPathBaseLLMClient, BedrockEmbeddings):
+    api_config: UiPathAPIConfig = UiPathAPIConfig(
+        api_type="embeddings",
+        client_type="passthrough",
+        vendor_type="awsbedrock",
+        freeze_base_url=True,
+    )
+
+    # Override fields to avoid errors when instantiating the class
+    model_id: str = "PLACEHOLDER"
+    region_name: str | None = "PLACEHOLDER"
+
+    @model_validator(mode="after")
+    def setup_uipath_client(self) -> Self:
+        self.model_id = self.model_name
+        self.client = WrappedBotoClient(self.uipath_sync_client)
+        return self

uipath_langchain_client/clients/bedrock/utils.py

@@ -0,0 +1,90 @@
+import base64
+import json
+from typing import Any, Iterator
+
+from httpx import Client
+
+try:
+    from botocore.eventstream import EventStreamBuffer
+except ImportError as e:
+    raise ImportError(
+        "The 'aws' extra is required to use WrappedBotoClient. "
+        "Install it with: uv add uipath-langchain-client[aws]"
+    ) from e
+
+
+class _MockEventHooks:
+    """Mock event hooks that mimics boto3's event registration system."""
+
+    def register(self, event_name: str, handler: Any) -> None:
+        """No-op register method to satisfy langchain_aws's header registration."""
+        pass
+
+
+class _MockClientMeta:
+    """Mock client meta that mimics boto3's client.meta structure."""
+
+    def __init__(self, region_name: str = "PLACEHOLDER"):
+        self.region_name = region_name
+        self.events = _MockEventHooks()
+
+
+class WrappedBotoClient:
+    def __init__(self, httpx_client: Client | None = None, region_name: str = "PLACEHOLDER"):
+        self.httpx_client = httpx_client
+        self.meta = _MockClientMeta(region_name=region_name)
+
+    def _stream_generator(self, request_body: dict[str, Any]) -> Iterator[dict[str, Any]]:
+        if self.httpx_client is None:
+            raise ValueError("httpx_client is not set")
+        with self.httpx_client.stream("POST", "/", json=request_body) as response:
+            buffer = EventStreamBuffer()
+            for chunk in response.iter_bytes():
+                buffer.add_data(chunk)
+                for event in buffer:
+                    event_as_dict = event.to_response_dict()
+                    dict_key = event_as_dict["headers"][":event-type"]
+                    dict_value = json.loads(event_as_dict["body"].decode("utf-8"))
+                    if "bytes" in dict_value:
+                        dict_value["bytes"] = base64.b64decode(dict_value["bytes"])
+                    yield {dict_key: dict_value}
+
+    def invoke_model(self, **kwargs: Any) -> Any:
+        if self.httpx_client is None:
+            raise ValueError("httpx_client is not set")
+        return {
+            "body": self.httpx_client.post(
+                "/",
+                json=json.loads(kwargs.get("body", {})),
+            )
+        }
+
+    def invoke_model_with_response_stream(self, **kwargs: Any) -> Any:
+        return {"body": self._stream_generator(json.loads(kwargs.get("body", {})))}
+
+    def converse(
+        self, *, messages: list[dict[str, Any]], system: str | None = None, **params: Any
+    ) -> Any:
+        if self.httpx_client is None:
+            raise ValueError("httpx_client is not set")
+        return self.httpx_client.post(
+            "/",
+            json={
+                "messages": messages,
+                "system": system,
+                **params,
+            },
+        ).json()
+
+    def converse_stream(
+        self, *, messages: list[dict[str, Any]], system: str | None = None, **params: Any
+    ) -> Any:
+        return {
+            "stream": self._stream_generator(
+                {
+                    "messages": messages,
+                    "system": system,
+                    **params,
+                }
+            ),
+        }

uipath_langchain_client/clients/google/__init__.py

@@ -0,0 +1,4 @@
+from uipath_langchain_client.clients.google.chat_models import UiPathChatGoogleGenerativeAI
+from uipath_langchain_client.clients.google.embeddings import UiPathGoogleGenerativeAIEmbeddings
+
+__all__ = ["UiPathChatGoogleGenerativeAI", "UiPathGoogleGenerativeAIEmbeddings"]

uipath_langchain_client/clients/google/chat_models.py

@@ -0,0 +1,203 @@
+from collections.abc import AsyncIterator, Iterator
+from typing import Self
+
+from httpx import Response
+from pydantic import Field, SecretStr, model_validator
+from uipath_langchain_client.base_client import UiPathBaseLLMClient
+from uipath_langchain_client.settings import UiPathAPIConfig
+
+try:
+    from langchain_google_genai.chat_models import ChatGoogleGenerativeAI
+
+    from google.genai.client import Client
+    from google.genai.types import HttpOptions
+except ImportError as e:
+    raise ImportError(
+        "The 'google' extra is required to use UiPathChatGoogleGenerativeAI. "
+        "Install it with: uv add uipath-langchain-client[google]"
+    ) from e
+
+
+def _wrap_iter_lines(original: Iterator[str]) -> Iterator[str]:
+    """Wrap iter_lines to extract individual JSON objects from streaming responses.
+
+    The LLM Gateway wraps streaming JSON responses in an array like [{...}, {...}].
+    This extracts each complete JSON object and yields them individually.
+    Handles multiple JSON objects on a single line (e.g., {...},{...}).
+
+    We prefix output with 'data: ' so the SDK's _iter_response_stream bypasses its
+    broken brace counting (which doesn't handle braces inside strings) and yields
+    our JSON objects directly.
+
+    Temporal Fix until it's fixed in the main package.
+    """
+    buffer = ""
+    balance = 0
+    in_string = False
+    escape_next = False
+
+    for line in original:
+        # Handle data: prefix (SSE format)
+        if line.startswith("data:"):
+            line = line[5:].lstrip()
+
+        for char in line:
+            # Handle escape sequences in strings
+            if escape_next:
+                buffer += char
+                escape_next = False
+                continue
+
+            if char == "\\" and in_string:
+                buffer += char
+                escape_next = True
+                continue
+
+            if char == '"':
+                in_string = not in_string
+                buffer += char
+                continue
+
+            # Only track braces outside of strings
+            if not in_string:
+                if char == "{":
+                    balance += 1
+                    buffer += char
+                elif char == "}":
+                    buffer += char
+                    balance -= 1
+                    if balance == 0 and buffer:
+                        # Complete JSON object found - yield with 'data: ' prefix
+                        # so SDK bypasses its broken brace counting
+                        yield "data: " + buffer
+                        buffer = ""
+                elif balance == 0:
+                    # Skip characters outside JSON objects (array brackets, commas, whitespace)
+                    continue
+                else:
+                    buffer += char
+            else:
+                buffer += char
+
+    # Yield any remaining buffer (handles incomplete streams)
+    if buffer:
+        yield "data: " + buffer
+
+
+async def _wrap_aiter_lines(original: AsyncIterator[str]) -> AsyncIterator[str]:
+    """Async version of _wrap_iter_lines.
+
+    Extracts individual JSON objects from streaming responses.
+    Handles multiple JSON objects on a single line (e.g., {...},{...}).
+
+    We prefix output with 'data: ' so the SDK's _iter_response_stream bypasses its
+    broken brace counting (which doesn't handle braces inside strings) and yields
+    our JSON objects directly.
+    """
+    buffer = ""
+    balance = 0
+    in_string = False
+    escape_next = False
+
+    async for line in original:
+        # Handle data: prefix (SSE format)
+        if line.startswith("data:"):
+            line = line[5:].lstrip()
+
+        for char in line:
+            # Handle escape sequences in strings
+            if escape_next:
+                buffer += char
+                escape_next = False
+                continue
+
+            if char == "\\" and in_string:
+                buffer += char
+                escape_next = True
+                continue
+
+            if char == '"':
+                in_string = not in_string
+                buffer += char
+                continue
+
+            # Only track braces outside of strings
+            if not in_string:
+                if char == "{":
+                    balance += 1
+                    buffer += char
+                elif char == "}":
+                    buffer += char
+                    balance -= 1
+                    if balance == 0 and buffer:
+                        # Complete JSON object found - yield with 'data: ' prefix
+                        # so SDK bypasses its broken brace counting
+                        yield "data: " + buffer
+                        buffer = ""
+                elif balance == 0:
+                    # Skip characters outside JSON objects (array brackets, commas, whitespace)
+                    continue
+                else:
+                    buffer += char
+            else:
+                buffer += char
+
+    # Yield any remaining buffer (handles incomplete streams)
+    if buffer:
+        yield "data: " + buffer
+
+
+class UiPathChatGoogleGenerativeAI(UiPathBaseLLMClient, ChatGoogleGenerativeAI):
+    api_config: UiPathAPIConfig = UiPathAPIConfig(
+        api_type="completions",
+        client_type="passthrough",
+        vendor_type="vertexai",
+        api_flavor="generate-content",
+        api_version="v1beta1",
+        freeze_base_url=True,
+    )
+
+    # Override fields to avoid errors when instantiating the class
+    model: str = Field(default="", alias="model_name")
+    google_api_key: SecretStr | None = Field(default=SecretStr("PLACEHOLDER"))
+
+    @model_validator(mode="after")
+    def setup_uipath_client(self) -> Self:
+        def fix_streaming_response(response: Response):
+            """Monkey-patch iter_lines to strip JSON array brackets."""
+            original_iter_lines = response.iter_lines
+            response.iter_lines = lambda: _wrap_iter_lines(original_iter_lines())
+
+        async def fix_streaming_response_async(response: Response):
+            """Monkey-patch aiter_lines to strip JSON array brackets."""
+            original_aiter_lines = response.aiter_lines
+            response.aiter_lines = lambda: _wrap_aiter_lines(original_aiter_lines())
+
+        self.uipath_sync_client.event_hooks["response"].append(fix_streaming_response)
+        self.uipath_async_client.event_hooks["response"].append(fix_streaming_response_async)
+
+        # TODO: in exactly 2 weeks, we need to uncomment this part of the code because it will work, 5 february 2026 is the date.
+        # def fix_url_for_streaming(request: Request):
+        #     if request.headers.get("X-UiPath-Streaming-Enabled") == "true":
+        #         request.url = URL(request.url).copy_add_param("alt", "sse")
+
+        # async def fix_url_for_streaming_async(request: Request):
+        #     if request.headers.get("X-UiPath-Streaming-Enabled") == "true":
+        #         request.url = URL(request.url).copy_add_param("alt", "sse")
+
+        # self.uipath_sync_client.event_hooks["request"].append(fix_url_for_streaming)
+        # self.uipath_async_client.event_hooks["request"].append(fix_url_for_streaming_async)
+
+        self.client = Client(
+            vertexai=True,
+            api_key="PLACEHOLDER",
+            http_options=HttpOptions(
+                base_url=str(self.uipath_sync_client.base_url),
+                headers=dict(self.uipath_sync_client.headers),
+                timeout=None,  # handled by the UiPath client
+                retry_options=None,  # handled by the UiPath client
+                httpx_client=self.uipath_sync_client,
+                httpx_async_client=self.uipath_async_client,
+            ),
+        )
+        return self

uipath_langchain_client/clients/google/embeddings.py

@@ -0,0 +1,45 @@
+from typing import Self
+
+from pydantic import Field, SecretStr, model_validator
+from uipath_langchain_client.base_client import UiPathBaseLLMClient
+from uipath_langchain_client.settings import UiPathAPIConfig
+
+try:
+    from langchain_google_genai.embeddings import GoogleGenerativeAIEmbeddings
+
+    from google.genai.client import Client
+    from google.genai.types import HttpOptions
+except ImportError as e:
+    raise ImportError(
+        "The 'google' extra is required to use UiPathGoogleGenerativeAIEmbeddings. "
+        "Install it with: uv add uipath-langchain-client[google]"
+    ) from e
+
+
+class UiPathGoogleGenerativeAIEmbeddings(UiPathBaseLLMClient, GoogleGenerativeAIEmbeddings):
+    api_config: UiPathAPIConfig = UiPathAPIConfig(
+        api_type="embeddings",
+        client_type="passthrough",
+        vendor_type="vertexai",
+        freeze_base_url=True,
+    )
+
+    # Override fields to avoid errors when instantiating the class
+    model: str = Field(default="", alias="model_name")
+    google_api_key: SecretStr | None = Field(default=SecretStr("PLACEHOLDER"))
+
+    @model_validator(mode="after")
+    def setup_uipath_client(self) -> Self:
+        self.client = Client(
+            vertexai=True,
+            api_key="PLACEHOLDER",
+            http_options=HttpOptions(
+                timeout=None,  # handled by the UiPath client
+                retry_options=None,  # handled by the UiPath client
+                base_url=str(self.uipath_sync_client.base_url),
+                headers=dict(self.uipath_sync_client.headers),
+                httpx_client=self.uipath_sync_client,
+                httpx_async_client=self.uipath_async_client,
+            ),
+        )
+        return self

uipath_langchain_client/clients/normalized/__init__.py

@@ -0,0 +1,4 @@
+from uipath_langchain_client.clients.normalized.chat_models import UiPathNormalizedChatModel
+from uipath_langchain_client.clients.normalized.embeddings import UiPathNormalizedEmbeddings
+
+__all__ = ["UiPathNormalizedChatModel", "UiPathNormalizedEmbeddings"]