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

uipath_langchain_client/clients/vertexai/chat_models.py

@@ -0,0 +1,48 @@
+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 anthropic import AnthropicVertex, AsyncAnthropicVertex
+    from langchain_google_vertexai.model_garden import ChatAnthropicVertex
+except ImportError as e:
+    raise ImportError(
+        "The 'vertexai' extra is required to use UiPathChatAnthropicVertex. "
+        "Install it with: uv add uipath-langchain-client[vertexai]"
+    ) from e
+
+
+class UiPathChatAnthropicVertex(UiPathBaseLLMClient, ChatAnthropicVertex):  # type: ignore[override]
+    api_config: UiPathAPIConfig = UiPathAPIConfig(
+        api_type="completions",
+        client_type="passthrough",
+        vendor_type="vertexai",
+        api_flavor="anthropic-claude",
+        freeze_base_url=True,
+    )
+
+    @model_validator(mode="after")
+    def setup_uipath_client(self) -> Self:
+        self.client = AnthropicVertex(
+            region="PLACEHOLDER",
+            project_id="PLACEHOLDER",
+            access_token="PLACEHOLDER",
+            base_url=str(self.uipath_sync_client.base_url),
+            default_headers=self.uipath_sync_client.headers,
+            timeout=None,  # handled by the UiPath client
+            max_retries=1,  # handled by the UiPath client
+            http_client=self.uipath_sync_client,
+        )
+        self.async_client = AsyncAnthropicVertex(
+            region="PLACEHOLDER",
+            project_id="PLACEHOLDER",
+            access_token="PLACEHOLDER",
+            base_url=str(self.uipath_async_client.base_url),
+            default_headers=self.uipath_async_client.headers,
+            timeout=None,  # handled by the UiPath client
+            max_retries=1,  # handled by the UiPath client
+            http_client=self.uipath_async_client,
+        )
+        return self

uipath_langchain_client/factory.py

@@ -0,0 +1,217 @@
+"""
+Factory Module for UiPath LangChain Client
+
+This module provides factory functions that automatically detect the appropriate
+LangChain model class based on the model name and vendor. This simplifies usage
+by eliminating the need to manually import provider-specific classes.
+
+The factory queries UiPath's discovery endpoint to determine which vendor
+(OpenAI, Google, Anthropic, etc.) provides a given model, then instantiates
+the correct LangChain wrapper class.
+
+Example:
+    >>> from uipath_langchain_client import get_chat_model, get_embedding_model
+    >>> from uipath_langchain_client.settings import get_default_client_settings
+    >>>
+    >>> settings = get_default_client_settings()
+    >>>
+    >>> # Auto-detect vendor from model name
+    >>> chat = get_chat_model("gpt-4o-2024-11-20", settings)
+    >>> embeddings = get_embedding_model("text-embedding-3-large", settings)
+"""
+
+from typing import Any, Literal
+
+from langchain_core.embeddings import Embeddings
+from langchain_core.language_models.chat_models import BaseChatModel
+
+from uipath_langchain_client.settings import UiPathBaseSettings, get_default_client_settings
+
+
+def _get_model_info(
+    model_name: str,
+    client_settings: UiPathBaseSettings,
+    byo_connection_id: str | None = None,
+) -> dict[str, Any]:
+    available_models = client_settings.get_available_models()
+
+    matching_models = [m for m in available_models if m["modelName"].lower() == model_name.lower()]
+
+    if byo_connection_id:
+        matching_models = [
+            m
+            for m in matching_models
+            if (byom_details := m.get("byomDetails"))
+            and byom_details.get("integrationServiceConnectionId", "").lower()
+            == byo_connection_id.lower()
+        ]
+
+    if not byo_connection_id and len(matching_models) > 1:
+        matching_models = [m for m in matching_models if m.get("byomDetails") is None]
+
+    if not matching_models:
+        raise ValueError(
+            f"Model {model_name} not found in available models the available models are: {[m['modelName'] for m in available_models]}"
+        )
+
+    return matching_models[0]
+
+
+def get_chat_model(
+    model_name: str,
+    byo_connection_id: str | None = None,
+    client_settings: UiPathBaseSettings | None = None,
+    client_type: Literal["passthrough", "normalized"] = "passthrough",
+    **model_kwargs: Any,
+) -> BaseChatModel:
+    """Factory function to create the appropriate LangChain chat model for a given model name.
+
+    Automatically detects the model vendor and returns the correct LangChain model class.
+
+    Args:
+        model: Name of the model to use (e.g., "gpt-4", "claude-3-opus")
+        client_type: Use "normalized" for provider-agnostic API or "passthrough" for vendor-specific
+        **model_kwargs: Additional keyword arguments to pass to the model constructor
+
+    Returns:
+        A LangChain BaseChatModel instance configured for the specified model
+
+    Raises:
+        ValueError: If the model is not found in available models or vendor is not supported
+    """
+    client_settings = client_settings or get_default_client_settings()
+    model_info = _get_model_info(model_name, client_settings, byo_connection_id)
+
+    if client_type == "normalized":
+        from uipath_langchain_client.clients.normalized.chat_models import (
+            UiPathNormalizedChatModel,
+        )
+
+        return UiPathNormalizedChatModel(model=model_name, **model_kwargs)
+
+    vendor_type = model_info["vendor"].lower()
+    match vendor_type:
+        case "openai":
+            if "gpt" in model_name:
+                from uipath_langchain_client.clients.openai.chat_models import (
+                    UiPathAzureChatOpenAI,
+                )
+
+                return UiPathAzureChatOpenAI(
+                    model=model_name,
+                    client_settings=client_settings,
+                    **model_kwargs,
+                )
+            else:
+                raise ValueError(f"Invalid model name: {model_name} for vendor: {vendor_type}")
+        case "vertexai":
+            if "gemini" in model_name:
+                from uipath_langchain_client.clients.google.chat_models import (
+                    UiPathChatGoogleGenerativeAI,
+                )
+
+                return UiPathChatGoogleGenerativeAI(
+                    model=model_name,
+                    client_settings=client_settings,
+                    **model_kwargs,
+                )
+            elif "claude" in model_name:
+                from uipath_langchain_client.clients.anthropic.chat_models import (
+                    UiPathChatAnthropic,
+                )
+
+                return UiPathChatAnthropic(
+                    model=model_name,
+                    client_settings=client_settings,
+                    vendor_type="vertexai",
+                    **model_kwargs,
+                )
+            else:
+                raise ValueError(f"Invalid model name: {model_name} for vendor: {vendor_type}")
+        case "awsbedrock":
+            if "claude" in model_name:
+                from uipath_langchain_client.clients.anthropic.chat_models import (
+                    UiPathChatAnthropic,
+                )
+
+                return UiPathChatAnthropic(
+                    model=model_name,
+                    client_settings=client_settings,
+                    vendor_type="awsbedrock",
+                    **model_kwargs,
+                )
+            else:
+                raise ValueError(f"Invalid model name: {model_name} for vendor: {vendor_type}")
+        case _:
+            raise ValueError(f"Invalid UiPath vendor type: {vendor_type}")
+
+
+def get_embedding_model(
+    model: str,
+    byo_connection_id: str | None = None,
+    client_settings: UiPathBaseSettings | None = None,
+    client_type: Literal["passthrough", "normalized"] = "passthrough",
+    **model_kwargs: Any,
+) -> Embeddings:
+    """Factory function to create the appropriate LangChain embeddings model.
+
+    Automatically detects the model vendor and returns the correct LangChain embeddings class.
+
+    Args:
+        model: Name of the embeddings model (e.g., "text-embedding-3-large").
+        client_settings: Client settings for authentication and routing.
+        client_type: API mode - "normalized" for provider-agnostic API or
+            "passthrough" for vendor-specific APIs.
+        **model_kwargs: Additional arguments passed to the embeddings constructor.
+
+    Returns:
+        A LangChain Embeddings instance configured for the specified model.
+
+    Raises:
+        ValueError: If the model is not found or the vendor is not supported.
+
+    Example:
+        >>> settings = get_default_client_settings()
+        >>> embeddings = get_embedding_model("text-embedding-3-large", settings)
+        >>> vectors = embeddings.embed_documents(["Hello world"])
+    """
+    client_settings = client_settings or get_default_client_settings()
+    model_info = _get_model_info(model, client_settings, byo_connection_id)
+
+    if client_type == "normalized":
+        from uipath_langchain_client.clients.normalized.embeddings import (
+            UiPathNormalizedEmbeddings,
+        )
+
+        return UiPathNormalizedEmbeddings(
+            model=model, client_settings=client_settings, **model_kwargs
+        )
+
+    vendor_type = model_info["vendor"].lower()
+    match vendor_type:
+        case "openai":
+            from uipath_langchain_client.clients.openai.embeddings import (
+                UiPathAzureOpenAIEmbeddings,
+            )
+
+            return UiPathAzureOpenAIEmbeddings(
+                model=model, client_settings=client_settings, **model_kwargs
+            )
+        case "vertexai":
+            from uipath_langchain_client.clients.google.embeddings import (
+                UiPathGoogleGenerativeAIEmbeddings,
+            )
+
+            return UiPathGoogleGenerativeAIEmbeddings(
+                model=model, client_settings=client_settings, **model_kwargs
+            )
+        case "awsbedrock":
+            from uipath_langchain_client.clients.bedrock.embeddings import (
+                UiPathBedrockEmbeddings,
+            )
+
+            return UiPathBedrockEmbeddings(
+                model=model, client_settings=client_settings, **model_kwargs
+            )
+        case _:
+            raise ValueError(f"Invalid UiPath Embeddings provider: {vendor_type}")

uipath_langchain_client/settings.py

@@ -0,0 +1,32 @@
+"""
+Settings re-exports for UiPath LangChain Client.
+
+This module re-exports the settings classes from uipath_llm_client for convenience,
+allowing users to configure authentication without importing from the base package.
+
+Example:
+    >>> from uipath_langchain_client.settings import get_default_client_settings
+    >>>
+    >>> # Auto-detect backend from environment (defaults to AgentHub)
+    >>> settings = get_default_client_settings()
+    >>>
+    >>> # Or explicitly use LLMGateway
+    >>> from uipath_langchain_client.settings import LLMGatewaySettings
+    >>> settings = LLMGatewaySettings()
+"""
+
+from uipath_llm_client.settings import (
+    AgentHubSettings,
+    LLMGatewaySettings,
+    UiPathAPIConfig,
+    UiPathBaseSettings,
+    get_default_client_settings,
+)
+
+__all__ = [
+    "get_default_client_settings",
+    "LLMGatewaySettings",
+    "AgentHubSettings",
+    "UiPathAPIConfig",
+    "UiPathBaseSettings",
+]

uipath_langchain_client-1.0.0.dist-info/METADATA

@@ -0,0 +1,276 @@
+Metadata-Version: 2.4
+Name: uipath-langchain-client
+Version: 1.0.0
+Summary: LangChain-compatible chat models and embeddings for UiPath's LLM services
+Requires-Python: >=3.11
+Requires-Dist: langchain>=1.2.7
+Requires-Dist: uipath-llm-client>=1.0.0
+Provides-Extra: all
+Requires-Dist: langchain-anthropic>=1.3.1; extra == 'all'
+Requires-Dist: langchain-aws>=1.2.1; extra == 'all'
+Requires-Dist: langchain-azure-ai>=1.0.0; extra == 'all'
+Requires-Dist: langchain-google-genai>=4.2.0; extra == 'all'
+Requires-Dist: langchain-google-vertexai>=3.2.1; extra == 'all'
+Requires-Dist: langchain-openai>=1.1.7; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: langchain-anthropic>=1.3.1; extra == 'anthropic'
+Provides-Extra: aws
+Requires-Dist: langchain-aws>=1.2.1; extra == 'aws'
+Provides-Extra: azure
+Requires-Dist: langchain-azure-ai>=1.0.0; extra == 'azure'
+Provides-Extra: google
+Requires-Dist: langchain-google-genai>=4.2.0; extra == 'google'
+Provides-Extra: openai
+Requires-Dist: langchain-openai>=1.1.7; extra == 'openai'
+Provides-Extra: vertexai
+Requires-Dist: langchain-google-vertexai>=3.2.1; extra == 'vertexai'
+Description-Content-Type: text/markdown
+
+# UiPath LangChain Client
+
+LangChain-compatible chat models and embeddings for accessing LLMs through UiPath's infrastructure.
+
+## Installation
+
+```bash
+# Base installation (normalized API only)
+pip install uipath-langchain-client
+
+# With specific provider extras for passthrough mode
+pip install "uipath-langchain-client[openai]"      # OpenAI/Azure models
+pip install "uipath-langchain-client[google]"      # Google Gemini models
+pip install "uipath-langchain-client[anthropic]"   # Anthropic Claude models
+pip install "uipath-langchain-client[azure]"       # Azure AI models
+pip install "uipath-langchain-client[aws]"         # AWS Bedrock models
+pip install "uipath-langchain-client[vertexai]"    # Google VertexAI models
+pip install "uipath-langchain-client[all]"         # All providers
+```
+
+## Quick Start
+
+### Using Factory Functions (Recommended)
+
+The factory functions automatically detect the model vendor and return the appropriate client:
+
+```python
+from uipath_langchain_client import get_chat_model, get_embedding_model
+from uipath_langchain_client.settings import get_default_client_settings
+
+# Get default settings (uses UIPATH_LLM_BACKEND env var or defaults to AgentHub)
+settings = get_default_client_settings()
+
+# Chat model - vendor auto-detected from model name
+chat_model = get_chat_model(
+    model_name="gpt-4o-2024-11-20",
+    client_settings=settings,
+)
+response = chat_model.invoke("Hello, how are you?")
+print(response.content)
+
+# Embeddings model
+embeddings = get_embedding_model(
+    model="text-embedding-3-large",
+    client_settings=settings,
+)
+vectors = embeddings.embed_documents(["Hello world"])
+print(f"Embedding dimension: {len(vectors[0])}")
+```
+
+### Using Direct Client Classes
+
+For more control, instantiate provider-specific classes directly:
+
+```python
+from uipath_langchain_client.openai.chat_models import UiPathAzureChatOpenAI
+from uipath_langchain_client.google.chat_models import UiPathChatGoogleGenerativeAI
+from uipath_langchain_client.anthropic.chat_models import UiPathChatAnthropic
+from uipath_langchain_client.normalized.chat_models import UiPathNormalizedChatModel
+from uipath_langchain_client.settings import get_default_client_settings
+
+settings = get_default_client_settings()
+
+# OpenAI/Azure
+openai_chat = UiPathAzureChatOpenAI(model="gpt-4o-2024-11-20", client_settings=settings)
+
+# Google Gemini
+gemini_chat = UiPathChatGoogleGenerativeAI(model="gemini-2.5-flash", client_settings=settings)
+
+# Anthropic Claude (via AWS Bedrock)
+claude_chat = UiPathChatAnthropic(
+    model="anthropic.claude-sonnet-4-5-20250929-v1:0",
+    client_settings=settings,
+    vendor_type="awsbedrock",
+)
+
+# Normalized (provider-agnostic)
+normalized_chat = UiPathNormalizedChatModel(model="gpt-4o-2024-11-20", client_settings=settings)
+```
+
+## Available Client Types
+
+### Passthrough Mode (Default)
+
+Uses vendor-specific APIs through UiPath's gateway. Full feature parity with native SDKs.
+
+| Class | Provider | Models |
+|-------|----------|--------|
+| `UiPathAzureChatOpenAI` | OpenAI/Azure | GPT-4o, GPT-4, GPT-3.5 |
+| `UiPathChatOpenAI` | OpenAI | GPT-4o, GPT-4, GPT-3.5 |
+| `UiPathChatGoogleGenerativeAI` | Google | Gemini 2.5, 2.0, 1.5 |
+| `UiPathChatAnthropic` | Anthropic | Claude Sonnet 4.5, Opus, etc. |
+| `UiPathChatAnthropicVertex` | Anthropic (via VertexAI) | Claude models |
+| `UiPathAzureAIChatCompletionsModel` | Azure AI | Various |
+
+### Normalized Mode
+
+Uses UiPath's normalized API for a consistent interface across all providers.
+
+| Class | Description |
+|-------|-------------|
+| `UiPathNormalizedChatModel` | Provider-agnostic chat completions |
+| `UiPathNormalizedEmbeddings` | Provider-agnostic embeddings |
+
+## Features
+
+### Streaming
+
+```python
+from uipath_langchain_client import get_chat_model
+from uipath_langchain_client.settings import get_default_client_settings
+
+settings = get_default_client_settings()
+chat_model = get_chat_model(model_name="gpt-4o-2024-11-20", client_settings=settings)
+
+# Sync streaming
+for chunk in chat_model.stream("Write a haiku about Python"):
+    print(chunk.content, end="", flush=True)
+
+# Async streaming
+async for chunk in chat_model.astream("Write a haiku about Python"):
+    print(chunk.content, end="", flush=True)
+```
+
+### Tool Calling
+
+```python
+from langchain_core.tools import tool
+
+@tool
+def get_weather(city: str) -> str:
+    """Get the current weather for a city."""
+    return f"Sunny, 72°F in {city}"
+
+chat_model = get_chat_model(model_name="gpt-4o-2024-11-20", client_settings=settings)
+model_with_tools = chat_model.bind_tools([get_weather])
+
+response = model_with_tools.invoke("What's the weather in Tokyo?")
+print(response.tool_calls)
+```
+
+### LangGraph Agents
+
+```python
+from langgraph.prebuilt import create_react_agent
+from langchain_core.tools import tool
+
+@tool
+def search(query: str) -> str:
+    """Search the web."""
+    return f"Results for: {query}"
+
+chat_model = get_chat_model(model_name="gpt-4o-2024-11-20", client_settings=settings)
+agent = create_react_agent(chat_model, [search])
+
+result = agent.invoke({"messages": [("user", "Search for UiPath documentation")]})
+```
+
+### Extended Thinking (Model-Specific)
+
+```python
+# OpenAI o1/o3 reasoning
+chat_model = get_chat_model(
+    model_name="o3-mini",
+    client_settings=settings,
+    client_type="normalized",
+    reasoning_effort="medium",  # "low", "medium", "high"
+)
+
+# Anthropic Claude thinking
+chat_model = get_chat_model(
+    model_name="claude-sonnet-4-5",
+    client_settings=settings,
+    client_type="normalized",
+    thinking={"type": "enabled", "budget_tokens": 10000},
+)
+
+# Gemini thinking
+chat_model = get_chat_model(
+    model_name="gemini-2.5-pro",
+    client_settings=settings,
+    client_type="normalized",
+    thinking_level="medium",
+    include_thoughts=True,
+)
+```
+
+## Configuration
+
+### Retry Configuration
+
+```python
+# RetryConfig is a TypedDict - all fields are optional with sensible defaults
+retry_config = {
+    "initial_delay": 2.0,   # Initial delay before first retry
+    "max_delay": 60.0,      # Maximum delay between retries
+    "exp_base": 2.0,        # Exponential backoff base
+    "jitter": 1.0,          # Random jitter to add
+}
+
+chat_model = get_chat_model(
+    model_name="gpt-4o-2024-11-20",
+    client_settings=settings,
+    max_retries=3,
+    retry_config=retry_config,
+)
+```
+
+### Request Timeout
+
+```python
+chat_model = get_chat_model(
+    model_name="gpt-4o-2024-11-20",
+    client_settings=settings,
+    request_timeout=120,  # Client-side timeout in seconds
+)
+```
+
+## API Reference
+
+### `get_chat_model()`
+
+Factory function to create a chat model.
+
+**Parameters:**
+- `model_name` (str): Name of the model (e.g., "gpt-4o-2024-11-20")
+- `client_settings` (UiPathBaseSettings): Client settings for authentication
+- `client_type` (Literal["passthrough", "normalized"]): API mode (default: "passthrough")
+- `**model_kwargs`: Additional arguments passed to the model constructor
+
+**Returns:** `BaseChatModel` - A LangChain-compatible chat model
+
+### `get_embedding_model()`
+
+Factory function to create an embeddings model.
+
+**Parameters:**
+- `model` (str): Name of the model (e.g., "text-embedding-3-large")
+- `client_settings` (UiPathBaseSettings): Client settings for authentication
+- `client_type` (Literal["passthrough", "normalized"]): API mode (default: "passthrough")
+- `**model_kwargs`: Additional arguments passed to the model constructor
+
+**Returns:** `Embeddings` - A LangChain-compatible embeddings model
+
+## See Also
+
+- [Main README](../../README.md) - Overview and core client documentation
+- [UiPath LLM Client](../../src/uipath_llm_client/) - Low-level HTTP client

uipath_langchain_client-1.0.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+uipath_langchain_client/__init__.py,sha256=3rOLh-mBT_DWUNShlnOzzcU9OxT98V7i_fQPcFRAGuQ,1605
+uipath_langchain_client/__version__.py,sha256=n7mSkMnVmsou1wB3oAqSDg6W0Wlr4Jo4fhedKAjOf-o,154
+uipath_langchain_client/base_client.py,sha256=ZOv51sfGpJLS0fQq0kUIy0v0BA_WF6jEFky9EgO7fpQ,10911
+uipath_langchain_client/factory.py,sha256=6KKAQqtdtDS8cwsZ5MUoChiqnDye41svbZ5CeUaggYg,8312
+uipath_langchain_client/settings.py,sha256=mcSXWzZ_jkG_y-1XJOJpDZH9YVHZd6MMbNMMHXujGjw,920
+uipath_langchain_client/clients/anthropic/__init__.py,sha256=cU7tkL3WYQXFZhdkZsQn_sgDQRx9wWzde3Amq0ts94U,121
+uipath_langchain_client/clients/anthropic/chat_models.py,sha256=STj3V_OUORSZ5nKX0BluLxkBDg0VL293fq2ou6hh1Hg,6947
+uipath_langchain_client/clients/azure/__init__.py,sha256=TDeEtcanZNqqqpjPWY8vFOLmKjVIyLXyv4l8VYKlpfY,267
+uipath_langchain_client/clients/azure/chat_models.py,sha256=BvMgDYRGwHhHLbS24aBL0Esp0NOOyf9wP3OkAWLpYEM,1727
+uipath_langchain_client/clients/azure/embeddings.py,sha256=VNxzMNROa9ZIAXUhWsIKgZeRjXj0rNn0wWZlFyZnjZk,1628
+uipath_langchain_client/clients/bedrock/__init__.py,sha256=TDHsmYfsnYHCl7q2UwbABRio-0CfAMP__ry4bjMDVeI,298
+uipath_langchain_client/clients/bedrock/chat_models.py,sha256=F1LuKnwWjiZSeV1ZbsvkusWC10MtCowVJuBpO9S7luc,2149
+uipath_langchain_client/clients/bedrock/embeddings.py,sha256=rLv2bWG46i3CJDfd7X9dB3acASQwTNfcxksZ7TRQjtg,1141
+uipath_langchain_client/clients/bedrock/utils.py,sha256=YYWyerreQj4X2iR-Lsg1i7ELLUi9HLk63AXuzuHp4KM,3129
+uipath_langchain_client/clients/google/__init__.py,sha256=oWzq3pprWR-si-mZt40VrQ5f53f-O7AKSWzqP60VDHE,271
+uipath_langchain_client/clients/google/chat_models.py,sha256=OinMNzBZkmNWUcIqX1wu2EyjZmrbyCyss5H_ijKBJg0,7668
+uipath_langchain_client/clients/google/embeddings.py,sha256=jx2TmzvcxIcKA0iitm5-iqSIj0hqy5RmLnNXMXbkXns,1705
+uipath_langchain_client/clients/normalized/__init__.py,sha256=r0tJ3QvhZPcbNjZJz8ADVCVTcyV1nb0zluwhb-tAAMg,257
+uipath_langchain_client/clients/normalized/chat_models.py,sha256=kIs8kyW5OKWiNWnxn7o8hz6W-yizaFVvd3V7KZAC8Sw,16639
+uipath_langchain_client/clients/normalized/embeddings.py,sha256=CXIuqKZKSa663b0dOubAvp1zHmW6-CgM1M6i7-FcgTA,1275
+uipath_langchain_client/clients/openai/__init__.py,sha256=f6O7otwFkSc5CxVOHpZ1GHEW9g9K2rDg5P_R7cxTrXs,376
+uipath_langchain_client/clients/openai/chat_models.py,sha256=fAaDeR5bQ6FFgufP0Qq8Hs3f-1QKHvLNvghGw18pGzQ,4029
+uipath_langchain_client/clients/openai/embeddings.py,sha256=qMuXmuv2G4WWtEeOGqEpz27DnEPKED3e3M4LOGGTwgw,3226
+uipath_langchain_client/clients/vertexai/__init__.py,sha256=g_rPq14ij0DPxUC4tX7vNDB5KVvfULxOUXyReM97PZw,132
+uipath_langchain_client/clients/vertexai/chat_models.py,sha256=K1yG_uXnjryFz6tg4UZepNnRVB6IQd6zhdDo4Sp9ubQ,1880
+uipath_langchain_client-1.0.0.dist-info/METADATA,sha256=OD-1MZCwNjYriN3U4RwM0S4nG-ER6-fxQSvT7wGpwX4,8762
+uipath_langchain_client-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+uipath_langchain_client-1.0.0.dist-info/RECORD,,

uipath_langchain_client-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any