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

uipath_langchain_client/__init__.py

@@ -0,0 +1,50 @@
+"""
+UiPath LangChain Client
+
+LangChain-compatible chat models and embeddings for accessing LLMs through
+UiPath's infrastructure (AgentHub or LLM Gateway).
+
+Quick Start:
+    >>> from uipath_langchain_client import (
+    ...     get_chat_model,
+    ...     get_embedding_model,
+    ...     get_default_client_settings,
+    ... )
+    >>>
+    >>> # Get settings (auto-detects backend from environment)
+    >>> settings = get_default_client_settings()
+    >>>
+    >>> # Chat model with auto-detected vendor
+    >>> chat = get_chat_model("gpt-4o-2024-11-20", settings)
+    >>> response = chat.invoke("Hello!")
+    >>>
+    >>> # Embeddings model
+    >>> embeddings = get_embedding_model("text-embedding-3-large", settings)
+    >>> vectors = embeddings.embed_documents(["Hello world"])
+
+Settings:
+    - get_default_client_settings(): Auto-detect backend from environment
+    - AgentHubSettings: UiPath AgentHub backend (CLI-based auth)
+    - LLMGatewaySettings: UiPath LLM Gateway backend (S2S auth)
+
+Factory Functions:
+    - get_chat_model(): Create a chat model with auto-detected vendor
+    - get_embedding_model(): Create an embeddings model with auto-detected vendor
+"""
+
+from uipath_langchain_client.__version__ import __version__
+from uipath_langchain_client.factory import get_chat_model, get_embedding_model
+from uipath_langchain_client.settings import (
+    AgentHubSettings,
+    LLMGatewaySettings,
+    get_default_client_settings,
+)
+
+__all__ = [
+    "__version__",
+    "get_chat_model",
+    "get_embedding_model",
+    "get_default_client_settings",
+    "LLMGatewaySettings",
+    "AgentHubSettings",
+]

uipath_langchain_client/__version__.py

@@ -0,0 +1,3 @@
+__title__ = "UiPath LangChain Client"
+__description__ = "A Python client for interacting with UiPath's LLM services via LangChain."
+__version__ = "1.0.0"

uipath_langchain_client/base_client.py

@@ -0,0 +1,277 @@
+"""
+UiPath LLM Client - Core HTTP Client Module
+
+This module provides the base HTTP client for interacting with UiPath's LLM services.
+It handles authentication, request/response formatting, retry logic, and logging.
+
+The UiPathBaseLLMClient class is designed to be used as a mixin with framework-specific
+chat models (e.g., LangChain, LlamaIndex) to provide UiPath connectivity.
+
+Example:
+    >>> from uipath_llm_client import UiPathBaseLLMClient, UiPathAPIConfig
+    >>> from uipath_langchain_client.settings import get_default_client_settings
+    >>>
+    >>> client = UiPathBaseLLMClient(
+    ...     model="gpt-4o-2024-11-20",
+    ...     api_config=UiPathAPIConfig(
+    ...         api_type="completions",
+    ...         client_type="passthrough",
+    ...         vendor_type="openai",
+    ...     ),
+    ...     client_settings=get_default_client_settings(),
+    ... )
+    >>> response = client.uipath_request(request_body={"messages": [...]})
+"""
+
+import logging
+from collections.abc import AsyncIterator, Iterator, Mapping
+from functools import cached_property
+from typing import Any, Literal
+
+from httpx import URL, Response
+from pydantic import BaseModel, ConfigDict, Field
+
+from uipath_langchain_client.settings import (
+    UiPathAPIConfig,
+    UiPathBaseSettings,
+    get_default_client_settings,
+)
+from uipath_llm_client.httpx_client import UiPathHttpxAsyncClient, UiPathHttpxClient
+from uipath_llm_client.utils.retry import RetryConfig
+
+
+class UiPathBaseLLMClient(BaseModel):
+    """Base HTTP client for interacting with UiPath's LLM services.
+
+    Provides the underlying HTTP transport layer with support for:
+        - Authentication and token management
+        - Request URL and header formatting
+        - Retry logic with configurable backoff
+        - Request/response logging
+
+    This class is typically used as a mixin with framework-specific chat models
+    (e.g., LangChain, LlamaIndex) to provide UiPath connectivity.
+
+    Attributes:
+        model_name: Name of the LLM model to use (aliased as "model")
+        byo_connection_id: Optional connection ID for Bring Your Own (BYO) models enrolled
+            in LLMGateway. When provided, routes requests to your custom-enrolled model.
+        api_config: API configuration (api_type, client_type, vendor_type, etc.)
+        client_settings: Client configuration (base URL, auth headers, etc.)
+        default_headers: Additional headers to include in requests
+        request_timeout: Client-side request timeout in seconds
+        retry_config: Configuration for retry behavior on failed requests
+        logger: Logger instance for request/response logging
+    """
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        validate_by_alias=True,
+        validate_by_name=True,
+        validate_default=True,
+    )
+
+    model_name: str = Field(
+        alias="model", description="the LLM model name (completions or embeddings)"
+    )
+    byo_connection_id: str | None = Field(
+        default=None,
+        description="Bring Your Own (BYO) connection ID for custom models enrolled in LLMGateway. "
+        "Use this when you have enrolled your own model deployment and received a connection ID.",
+    )
+
+    api_config: UiPathAPIConfig = Field(
+        ...,
+        description="Settings for the UiPath API",
+    )
+    client_settings: UiPathBaseSettings = Field(
+        default_factory=get_default_client_settings,
+        description="Settings for the UiPath client (defaults based on UIPATH_LLM_BACKEND env var)",
+    )
+    default_headers: Mapping[str, str] | None = Field(
+        default={
+            "X-UiPath-LLMGateway-TimeoutSeconds": "30",  # server side timeout, default is 10, maximum is 300
+            "X-UiPath-LLMGateway-AllowFull4xxResponse": "true",  # allow full 4xx responses (default is false)
+        },
+        description="Default request headers to include in requests",
+    )
+
+    request_timeout: int | None = Field(
+        default=None,
+        description="Client-side request timeout in seconds",
+    )
+    max_retries: int = Field(
+        default=1,
+        description="Maximum number of retries for failed requests",
+    )
+    retry_config: RetryConfig | None = Field(
+        default=None,
+        description="Retry configuration for failed requests",
+    )
+    logger: logging.Logger | None = Field(
+        default=None,
+        description="Logger for request/response logging",
+    )
+
+    @cached_property
+    def uipath_sync_client(self) -> UiPathHttpxClient:
+        """Here we instantiate a synchronous HTTP client with the proper authentication pipeline, retry logic, logging etc."""
+        return UiPathHttpxClient(
+            model_name=self.model_name,
+            byo_connection_id=self.byo_connection_id,
+            api_config=self.api_config,
+            auth=self.client_settings.build_auth_pipeline(),
+            base_url=self.client_settings.build_base_url(
+                model_name=self.model_name, api_config=self.api_config
+            ),
+            headers={
+                **(self.default_headers or {}),
+                **self.client_settings.build_auth_headers(
+                    model_name=self.model_name, api_config=self.api_config
+                ),
+            },
+            timeout=self.request_timeout,
+            max_retries=self.max_retries,
+            retry_config=self.retry_config,
+            logger=self.logger,
+        )
+
+    @cached_property
+    def uipath_async_client(self) -> UiPathHttpxAsyncClient:
+        """Here we instantiate an asynchronous HTTP client with the proper authentication pipeline, retry logic, logging etc."""
+        return UiPathHttpxAsyncClient(
+            model_name=self.model_name,
+            byo_connection_id=self.byo_connection_id,
+            api_config=self.api_config,
+            auth=self.client_settings.build_auth_pipeline(),
+            base_url=self.client_settings.build_base_url(
+                model_name=self.model_name, api_config=self.api_config
+            ),
+            headers={
+                **(self.default_headers or {}),
+                **self.client_settings.build_auth_headers(
+                    model_name=self.model_name, api_config=self.api_config
+                ),
+            },
+            timeout=self.request_timeout,
+            max_retries=self.max_retries,
+            retry_config=self.retry_config,
+            logger=self.logger,
+        )
+
+    def uipath_request(
+        self,
+        method: str = "POST",
+        url: URL | str = "/",
+        *,
+        request_body: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> Response:
+        """Make a synchronous HTTP request to the UiPath API.
+
+        Args:
+            method: HTTP method (GET, POST, etc.). Defaults to "POST".
+            url: Request URL path. Defaults to "/".
+            request_body: JSON request body to send.
+            **kwargs: Additional arguments passed to httpx.Client.request().
+
+        Returns:
+            httpx.Response: The HTTP response from the API.
+
+        Raises:
+            UiPathAPIError: On HTTP 4xx/5xx responses (raised by transport layer).
+        """
+        return self.uipath_sync_client.request(method, url, json=request_body, **kwargs)
+
+    async def uipath_arequest(
+        self,
+        method: Literal["POST", "GET"] = "POST",
+        url: str = "/",
+        *,
+        request_body: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> Response:
+        """Make an asynchronous HTTP request to the UiPath API."""
+        return await self.uipath_async_client.request(method, url, json=request_body, **kwargs)
+
+    def uipath_stream(
+        self,
+        method: Literal["POST", "GET"] = "POST",
+        url: str = "/",
+        *,
+        request_body: dict[str, Any] | None = None,
+        stream_type: Literal["text", "bytes", "lines", "raw"] = "lines",
+        **kwargs: Any,
+    ) -> Iterator[str | bytes]:
+        """Make a synchronous streaming HTTP request to the UiPath API.
+
+        Args:
+            method: HTTP method (POST or GET). Defaults to "POST".
+            url: Request URL path. Defaults to "/".
+            request_body: JSON request body to send.
+            stream_type: Type of stream iteration:
+                - "text": Yield decoded text chunks
+                - "bytes": Yield raw byte chunks
+                - "lines": Yield complete lines (default, best for SSE)
+                - "raw": Yield raw response data
+            **kwargs: Additional arguments passed to httpx.Client.stream().
+
+        Yields:
+            str | bytes: Chunks of the streaming response.
+        """
+        with self.uipath_sync_client.stream(method, url, json=request_body, **kwargs) as response:
+            match stream_type:
+                case "text":
+                    for chunk in response.iter_text():
+                        yield chunk
+                case "bytes":
+                    for chunk in response.iter_bytes():
+                        yield chunk
+                case "lines":
+                    for chunk in response.iter_lines():
+                        yield chunk
+                case "raw":
+                    for chunk in response.iter_raw():
+                        yield chunk
+
+    async def uipath_astream(
+        self,
+        method: Literal["POST", "GET"] = "POST",
+        url: str = "/",
+        *,
+        request_body: dict[str, Any] | None = None,
+        stream_type: Literal["text", "bytes", "lines", "raw"] = "lines",
+        **kwargs: Any,
+    ) -> AsyncIterator[str | bytes]:
+        """Make an asynchronous streaming HTTP request to the UiPath API.
+
+        Args:
+            method: HTTP method (POST or GET). Defaults to "POST".
+            url: Request URL path. Defaults to "/".
+            request_body: JSON request body to send.
+            stream_type: Type of stream iteration:
+                - "text": Yield decoded text chunks
+                - "bytes": Yield raw byte chunks
+                - "lines": Yield complete lines (default, best for SSE)
+                - "raw": Yield raw response data
+            **kwargs: Additional arguments passed to httpx.AsyncClient.stream().
+
+        Yields:
+            str | bytes: Chunks of the streaming response.
+        """
+        async with self.uipath_async_client.stream(
+            method, url, json=request_body, **kwargs
+        ) as response:
+            match stream_type:
+                case "text":
+                    async for chunk in response.aiter_text():
+                        yield chunk
+                case "bytes":
+                    async for chunk in response.aiter_bytes():
+                        yield chunk
+                case "lines":
+                    async for chunk in response.aiter_lines():
+                        yield chunk
+                case "raw":
+                    async for chunk in response.aiter_raw():
+                        yield chunk

uipath_langchain_client/clients/anthropic/__init__.py

@@ -0,0 +1,3 @@
+from uipath_langchain_client.clients.anthropic.chat_models import UiPathChatAnthropic
+
+__all__ = ["UiPathChatAnthropic"]

uipath_langchain_client/clients/anthropic/chat_models.py

@@ -0,0 +1,157 @@
+from functools import cached_property
+from typing import Any, Literal, Self, override
+
+from pydantic import Field, model_validator
+from uipath_langchain_client.base_client import UiPathBaseLLMClient
+from uipath_langchain_client.settings import UiPathAPIConfig
+
+try:
+    from langchain_anthropic.chat_models import ChatAnthropic
+
+    from anthropic import (
+        Anthropic,
+        AnthropicBedrock,
+        AnthropicFoundry,
+        AnthropicVertex,
+        AsyncAnthropic,
+        AsyncAnthropicBedrock,
+        AsyncAnthropicFoundry,
+        AsyncAnthropicVertex,
+    )
+except ImportError as e:
+    raise ImportError(
+        "The 'anthropic' extra is required to use UiPathChatAnthropic. "
+        "Install it with: uv add uipath-langchain-client[anthropic]"
+    ) from e
+
+
+class UiPathChatAnthropic(UiPathBaseLLMClient, ChatAnthropic):
+    api_config: UiPathAPIConfig = UiPathAPIConfig(
+        api_type="completions",
+        client_type="passthrough",
+        vendor_type="anthropic",
+        freeze_base_url=True,
+    )
+    vendor_type: Literal["anthropic", "azure", "vertexai", "awsbedrock"] = "awsbedrock"
+
+    @model_validator(mode="after")
+    def setup_api_flavor_and_version(self) -> Self:
+        match self.vendor_type:
+            case "vertexai":
+                self.api_config.api_flavor = "anthropic-claude"
+                self.api_config.api_version = "v1beta1"
+            case "awsbedrock":
+                self.api_config.api_flavor = "invoke"
+            case _:
+                raise ValueError("Those vendors are currently not supported")
+        self.api_config.vendor_type = self.vendor_type
+        return self
+
+    # Override fields to avoid typing issues and fix stuff
+    stop_sequences: list[str] | None = Field(default=None, alias="stop")
+    model: str = Field(default="", alias="model_name")
+    default_request_timeout: float | None = None
+
+    @cached_property
+    def _anthropic_client(
+        self,
+    ) -> Anthropic | AnthropicVertex | AnthropicBedrock | AnthropicFoundry:
+        match self.vendor_type:
+            case "azure":
+                return AnthropicFoundry(
+                    api_key="PLACEHOLDER",
+                    base_url=str(self.uipath_sync_client.base_url),
+                    default_headers=dict(self.uipath_sync_client.headers),
+                    max_retries=1,  # handled by the UiPathBaseLLMClient
+                    timeout=None,  # handled by the UiPathBaseLLMClient
+                    http_client=self.uipath_sync_client,
+                )
+            case "vertexai":
+                return AnthropicVertex(
+                    region="PLACEHOLDER",
+                    project_id="PLACEHOLDER",
+                    access_token="PLACEHOLDER",
+                    base_url=str(self.uipath_sync_client.base_url),
+                    default_headers=dict(self.uipath_sync_client.headers),
+                    timeout=None,  # handled by the UiPathBaseLLMClient
+                    max_retries=1,  # handled by the UiPathBaseLLMClient
+                    http_client=self.uipath_sync_client,
+                )
+            case "awsbedrock":
+                return AnthropicBedrock(
+                    aws_access_key="PLACEHOLDER",
+                    aws_secret_key="PLACEHOLDER",
+                    aws_region="PLACEHOLDER",
+                    base_url=str(self.uipath_sync_client.base_url),
+                    default_headers=dict(self.uipath_sync_client.headers),
+                    timeout=None,  # handled by the UiPathBaseLLMClient
+                    max_retries=1,  # handled by the UiPathBaseLLMClient
+                    http_client=self.uipath_sync_client,
+                )
+            case "anthropic":
+                return Anthropic(
+                    api_key="PLACEHOLDER",
+                    base_url=str(self.uipath_sync_client.base_url),
+                    default_headers=dict(self.uipath_sync_client.headers),
+                    timeout=None,  # handled by the UiPathBaseLLMClient
+                    max_retries=1,  # handled by the UiPathBaseLLMClient
+                    http_client=self.uipath_sync_client,
+                )
+
+    @cached_property
+    def _async_anthropic_client(
+        self,
+    ) -> AsyncAnthropic | AsyncAnthropicVertex | AsyncAnthropicBedrock | AsyncAnthropicFoundry:
+        match self.vendor_type:
+            case "azure":
+                return AsyncAnthropicFoundry(
+                    api_key="PLACEHOLDER",
+                    base_url=str(self.uipath_async_client.base_url),
+                    default_headers=dict(self.uipath_async_client.headers),
+                    max_retries=1,  # handled by the UiPathBaseLLMClient
+                    timeout=None,  # handled by the UiPathBaseLLMClient
+                    http_client=self.uipath_async_client,
+                )
+            case "vertexai":
+                return AsyncAnthropicVertex(
+                    region="PLACEHOLDER",
+                    project_id="PLACEHOLDER",
+                    access_token="PLACEHOLDER",
+                    base_url=str(self.uipath_async_client.base_url),
+                    default_headers=dict(self.uipath_async_client.headers),
+                    timeout=None,  # handled by the UiPathBaseLLMClient
+                    max_retries=1,  # handled by the UiPathBaseLLMClient
+                    http_client=self.uipath_async_client,
+                )
+            case "awsbedrock":
+                return AsyncAnthropicBedrock(
+                    aws_access_key="PLACEHOLDER",
+                    aws_secret_key="PLACEHOLDER",
+                    aws_region="PLACEHOLDER",
+                    base_url=str(self.uipath_async_client.base_url),
+                    default_headers=dict(self.uipath_async_client.headers),
+                    timeout=None,  # handled by the UiPathBaseLLMClient
+                    max_retries=1,  # handled by the UiPathBaseLLMClient
+                    http_client=self.uipath_async_client,
+                )
+            case _:
+                return AsyncAnthropic(
+                    api_key="PLACEHOLDER",
+                    base_url=str(self.uipath_async_client.base_url),
+                    default_headers=dict(self.uipath_async_client.headers),
+                    timeout=None,  # handled by the UiPathBaseLLMClient
+                    max_retries=1,  # handled by the UiPathBaseLLMClient
+                    http_client=self.uipath_async_client,
+                )
+
+    @override
+    def _create(self, payload: dict) -> Any:
+        if "betas" in payload:
+            return self._anthropic_client.beta.messages.create(**payload)
+        return self._anthropic_client.messages.create(**payload)
+
+    @override
+    async def _acreate(self, payload: dict) -> Any:
+        if "betas" in payload:
+            return await self._async_anthropic_client.beta.messages.create(**payload)
+        return await self._async_anthropic_client.messages.create(**payload)

uipath_langchain_client/clients/azure/__init__.py

@@ -0,0 +1,4 @@
+from uipath_langchain_client.clients.azure.chat_models import UiPathAzureAIChatCompletionsModel
+from uipath_langchain_client.clients.azure.embeddings import UiPathAzureAIEmbeddingsModel
+
+__all__ = ["UiPathAzureAIChatCompletionsModel", "UiPathAzureAIEmbeddingsModel"]

uipath_langchain_client/clients/azure/chat_models.py

@@ -0,0 +1,46 @@
+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_azure_ai.chat_models import AzureAIChatCompletionsModel
+
+    from azure.ai.inference import ChatCompletionsClient
+    from azure.ai.inference.aio import ChatCompletionsClient as ChatCompletionsClientAsync
+    from azure.core.credentials import AzureKeyCredential
+except ImportError as e:
+    raise ImportError(
+        "The 'azure' extra is required to use UiPathAzureAIChatCompletionsModel. "
+        "Install it with: uv add uipath-langchain-client[azure]"
+    ) from e
+
+
+class UiPathAzureAIChatCompletionsModel(UiPathBaseLLMClient, AzureAIChatCompletionsModel):  # type: ignore[override]
+    api_config: UiPathAPIConfig = UiPathAPIConfig(
+        api_type="completions",
+        client_type="passthrough",
+        vendor_type="azure",
+        freeze_base_url=True,
+    )
+
+    # Override fields to avoid errors when instantiating the class
+    endpoint: str | None = "PLACEHOLDER"
+
+    @model_validator(mode="after")
+    def setup_uipath_client(self) -> Self:
+        # TODO: finish implementation once we have a proper model in UiPath API
+        self._client = ChatCompletionsClient(
+            endpoint="PLACEHOLDER",
+            credential=AzureKeyCredential("PLACEHOLDER"),
+            model=self.model_name,
+            **self.client_kwargs,
+        )
+        self._async_client = ChatCompletionsClientAsync(
+            endpoint="PLACEHOLDER",
+            credential=AzureKeyCredential("PLACEHOLDER"),
+            model=self.model_name,
+            **self.client_kwargs,
+        )
+        return self

uipath_langchain_client/clients/azure/embeddings.py

@@ -0,0 +1,46 @@
+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_azure_ai.embeddings import AzureAIEmbeddingsModel
+
+    from azure.ai.inference import EmbeddingsClient
+    from azure.ai.inference.aio import EmbeddingsClient as EmbeddingsClientAsync
+except ImportError as e:
+    raise ImportError(
+        "The 'azure' extra is required to use UiPathAzureAIEmbeddingsModel. "
+        "Install it with: uv add uipath-langchain-client[azure]"
+    ) from e
+
+
+class UiPathAzureAIEmbeddingsModel(UiPathBaseLLMClient, AzureAIEmbeddingsModel):  # type: ignore[override]
+    api_config: UiPathAPIConfig = UiPathAPIConfig(
+        api_type="embeddings",
+        client_type="passthrough",
+        vendor_type="azure",
+        freeze_base_url=True,
+    )
+
+    # Override fields to avoid errors when instantiating the class
+    endpoint: str | None = "PLACEHOLDER"
+    credentials: str | None = "PLACEHOLDER"
+
+    @model_validator(mode="after")
+    def setup_uipath_client(self) -> Self:
+        # TODO: finish implementation once we have a proper model in UiPath API
+        self._client = EmbeddingsClient(
+            endpoint="PLACEHOLDER",
+            credentials="PLACEHOLDER",
+            model=self.model_name,
+            **self.client_kwargs,
+        )
+        self._async_client = EmbeddingsClientAsync(
+            endpoint="PLACEHOLDER",
+            credentials="PLACEHOLDER",
+            model=self.model_name,
+            **self.client_kwargs,
+        )
+        return self

uipath_langchain_client/clients/bedrock/__init__.py

@@ -0,0 +1,7 @@
+from uipath_langchain_client.clients.bedrock.chat_models import (
+    UiPathChatBedrock,
+    UiPathChatBedrockConverse,
+)
+from uipath_langchain_client.clients.bedrock.embeddings import UiPathBedrockEmbeddings
+
+__all__ = ["UiPathChatBedrock", "UiPathChatBedrockConverse", "UiPathBedrockEmbeddings"]

uipath_langchain_client/clients/bedrock/chat_models.py

@@ -0,0 +1,63 @@
+from typing import Any, 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.chat_models import ChatBedrock, ChatBedrockConverse
+    from uipath_langchain_client.clients.bedrock.utils import WrappedBotoClient
+except ImportError as e:
+    raise ImportError(
+        "The 'aws' extra is required to use UiPathBedrockChatModel and UiPathBedrockChatModelConverse. "
+        "Install it with: uv add uipath-langchain-client[aws]"
+    ) from e
+
+
+class UiPathChatBedrockConverse(UiPathBaseLLMClient, ChatBedrockConverse):
+    api_config: UiPathAPIConfig = UiPathAPIConfig(
+        api_type="completions",
+        client_type="passthrough",
+        vendor_type="awsbedrock",
+        api_flavor="converse",
+        freeze_base_url=True,
+    )
+
+    # Override fields to avoid errors when instantiating the class
+    model_id: str = "PLACEHOLDER"
+    client: Any = WrappedBotoClient()
+    bedrock_client: Any = WrappedBotoClient()
+
+    @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
+
+
+class UiPathChatBedrock(UiPathBaseLLMClient, ChatBedrock):
+    api_config: UiPathAPIConfig = UiPathAPIConfig(
+        api_type="completions",
+        client_type="passthrough",
+        vendor_type="awsbedrock",
+        api_flavor="invoke",
+        freeze_base_url=True,
+    )
+
+    # Override fields to avoid errors when instantiating the class
+    model_id: str = "PLACEHOLDER"
+    client: Any = WrappedBotoClient()
+    bedrock_client: Any = WrappedBotoClient()
+
+    @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
+
+    @property
+    def _as_converse(self) -> UiPathChatBedrockConverse:
+        return UiPathChatBedrockConverse(
+            model=self.model_name,
+            client_settings=self.client_settings,
+        )