uipath-langchain 0.0.103__py3-none-any.whl → 0.0.105__py3-none-any.whl

uipath_langchain/retrievers/context_grounding_retriever.py

@@ -11,6 +11,8 @@ from uipath import UiPath
 
 class ContextGroundingRetriever(BaseRetriever):
     index_name: str
+    folder_path: Optional[str] = None
+    folder_key: Optional[str] = None
     uipath_sdk: Optional[UiPath] = None
     number_of_results: Optional[int] = 10
 
@@ -24,6 +26,8 @@ class ContextGroundingRetriever(BaseRetriever):
             self.index_name,
             query,
             self.number_of_results if self.number_of_results is not None else 10,
+            folder_path=self.folder_path,
+            folder_key=self.folder_key,
         )
 
         return [
@@ -47,6 +51,8 @@ class ContextGroundingRetriever(BaseRetriever):
             self.index_name,
             query,
             self.number_of_results if self.number_of_results is not None else 10,
+            folder_path=self.folder_path,
+            folder_key=self.folder_key,
         )
 
         return [

uipath_langchain/vectorstores/__init__.py

@@ -0,0 +1,3 @@
+from .context_grounding_vectorstore import ContextGroundingVectorStore
+
+__all__ = ["ContextGroundingVectorStore"]

{uipath_langchain-0.0.103.dist-info → uipath_langchain-0.0.105.dist-info}/METADATA

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.103
+Version: 0.0.105
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
+Project-URL: Documentation, https://uipath.github.io/uipath-python/
 Maintainer-email: Marius Cosareanu <marius.cosareanu@uipath.com>, Cristian Pufu <cristian.pufu@uipath.com>
 License-File: LICENSE
 Classifier: Development Status :: 3 - Alpha
@@ -23,8 +24,6 @@ Requires-Dist: langgraph>=0.2.70
 Requires-Dist: openai>=1.65.5
 Requires-Dist: pydantic-settings>=2.6.0
 Requires-Dist: python-dotenv>=1.0.1
-Requires-Dist: requests>=2.23.3
-Requires-Dist: types-requests>=2.32.0.20241016
 Requires-Dist: uipath<2.1.0,>=2.0.33
 Provides-Extra: langchain
 Description-Content-Type: text/markdown

{uipath_langchain-0.0.103.dist-info → uipath_langchain-0.0.105.dist-info}/RECORD

@@ -19,25 +19,20 @@ uipath_langchain/_utils/_settings.py,sha256=MhwEVj4gVRSar0RBf2w2hTjO-5Qm-HpCuufq
 uipath_langchain/_utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
 uipath_langchain/chat/__init__.py,sha256=WDcvy91ixvZ3Mq7Ae94g5CjyQwXovDBnEv1NlD5SXBE,116
 uipath_langchain/chat/models.py,sha256=sLz8yzEMUMSNsCFyywRxFwe2JisR3TP-n1vbeRKl9H8,10225
-uipath_langchain/chat/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-uipath_langchain/chat/utils/_chat_types.py,sha256=iTUh4gY8ML2yLzTQ7H4ZFXChA8RbPz7NgkJK4x7fSbs,1226
 uipath_langchain/embeddings/__init__.py,sha256=QICtYB58ZyqFfDQrEaO8lTEgAU5NuEKlR7iIrS0OBtc,156
 uipath_langchain/embeddings/embeddings.py,sha256=gntzTfwO1pHbgnXiPdfETJaaurvQWqxVUCH75VMah54,4274
 uipath_langchain/retrievers/__init__.py,sha256=rOn7PyyHgZ4pMnXWPkGqmuBmx8eGuo-Oyndo7Wm9IUU,108
-uipath_langchain/retrievers/context_grounding_retriever.py,sha256=CeVSMEz5xTQIladkzDLeQXGC1_ycW72gb0RB41JZeYA,2000
+uipath_langchain/retrievers/context_grounding_retriever.py,sha256=YLCIwy89LhLnNqcM0YJ5mZoeNyCs5UiKD3Wly8gnW1E,2239
 uipath_langchain/tracers/AsyncUiPathTracer.py,sha256=VLqoegxa8J3VwMCkGicO626nSzyCQv-Zj14lZrWXA2Y,8900
 uipath_langchain/tracers/UiPathTracer.py,sha256=V5g1nlB0TI1wYvUIkfCEcAdhy4thqeMBmjflWtxc-_M,5601
 uipath_langchain/tracers/__init__.py,sha256=MwrQh6iuPXMS72S5EX0JdCAX0TKe-l7fIPGV3EG0Ssk,256
 uipath_langchain/tracers/_events.py,sha256=CJri76SSdu7rGJIkXurJ2C5sQahfSK4E5UWwWYdEAtE,922
 uipath_langchain/tracers/_instrument_traceable.py,sha256=0e841zVzcPWjOGtmBx0GeHbq3JoqsmWv6gVPzDOKNTM,13496
 uipath_langchain/tracers/_utils.py,sha256=JOT1tKMdvqjMDtj2WbmbOWMeMlTXBWavxWpogX7KlRA,1543
-uipath_langchain/utils/__init__.py,sha256=-w-4TD9ZnJDCpj4VIPXhJciukrmDJJbmnOFnhAkAaEU,81
-uipath_langchain/utils/_request_mixin.py,sha256=WFyTDyAthSci1DRwUwS21I3hLntD7HdVzYc0ZPoi3ys,18296
-uipath_langchain/utils/_settings.py,sha256=MhwEVj4gVRSar0RBf2w2hTjO-5Qm-HpCuufqN3gSWjA,3390
-uipath_langchain/utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
+uipath_langchain/vectorstores/__init__.py,sha256=w8qs1P548ud1aIcVA_QhBgf_jZDrRMK5Lono78yA8cs,114
 uipath_langchain/vectorstores/context_grounding_vectorstore.py,sha256=eTa5sX43-ydB1pj9VNHUPbB-hC36fZK_CGrNe5U2Nrw,9393
-uipath_langchain-0.0.103.dist-info/METADATA,sha256=APsivdYkuoM0ek-as3rboX81hQmseePmqz0Tp-OrD-s,4177
-uipath_langchain-0.0.103.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.103.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.103.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.103.dist-info/RECORD,,
+uipath_langchain-0.0.105.dist-info/METADATA,sha256=1mIsfmBry1pZP1KS3VTTqKka1pK-0gcwr31rE5TEAMI,4166
+uipath_langchain-0.0.105.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_langchain-0.0.105.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
+uipath_langchain-0.0.105.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.0.105.dist-info/RECORD,,

uipath_langchain/chat/utils/_chat_types.py

@@ -1,54 +0,0 @@
-from typing import Any, Dict, List, Optional, Union
-
-from pydantic import BaseModel, Field
-
-
-class ToolCall(BaseModel):
-    id: str
-    name: str
-    arguments: Dict[Any, Any]
-
-
-class Message(BaseModel):
-    role: str
-    content: Optional[Union[str, Dict[Any, Any]]] = None
-    tool_calls: Optional[List[ToolCall]] = None
-
-
-class Tool(BaseModel):
-    name: str
-    description: str
-    parameters: Optional[Dict[Any, Any]] = None
-
-
-class ToolChoice(BaseModel):
-    type: str
-    name: Optional[str] = None
-
-
-class ChatCompletionRequest(BaseModel):
-    max_tokens: int
-    # n: int
-    # top_p: float
-    temperature: float
-    frequency_penalty: float
-    presence_penalty: float
-    messages: List[Message]
-    tools: Optional[List[Tool]] = None
-    tool_choice: Optional[ToolChoice] = None
-    response_format: Optional[Dict[str, Any]] = None
-
-
-class ModelSettings(BaseModel):
-    top_p: float = 1.0
-    n: int = 1
-    temperature: float = 0.0
-    frequency_penalty: float = 0.0
-    presence_penalty: float = 0.0
-    max_tokens: int = 4096
-    tool_choice: Optional[str] = None
-    enforced_tool_name: Optional[str] = None
-
-
-class UiPathOutput(BaseModel):
-    output_field: str = Field(..., description="The output field")

uipath_langchain/utils/__init__.py

@@ -1,3 +0,0 @@
-from ._request_mixin import UiPathRequestMixin
-
-__all__ = ["UiPathRequestMixin"]

uipath_langchain/utils/_request_mixin.py

@@ -1,488 +0,0 @@
-# mypy: disable-error-code="no-redef,arg-type"
-import json
-import logging
-import os
-import time
-from typing import Any, Dict, List, Mapping, Optional
-
-import httpx
-import openai
-from langchain_core.embeddings import Embeddings
-from langchain_core.language_models.chat_models import _cleanup_llm_representation
-from pydantic import BaseModel, Field, SecretStr
-from tenacity import (
-    AsyncRetrying,
-    Retrying,
-    retry_if_exception_type,
-    stop_after_attempt,
-    wait_exponential_jitter,
-)
-
-from uipath_langchain.utils._settings import (
-    UiPathClientFactorySettings,
-    UiPathClientSettings,
-    get_uipath_token_header,
-)
-from uipath_langchain.utils._sleep_policy import before_sleep_log
-
-
-def get_from_uipath_url():
-    url = os.getenv("UIPATH_URL")
-    if url:
-        return "/".join(url.split("/", 3)[:3])
-    return None
-
-
-class UiPathRequestMixin(BaseModel):
-    class Config:
-        arbitrary_types_allowed = True
-
-    default_headers: Optional[Mapping[str, str]] = {
-        "X-UiPath-Streaming-Enabled": "false",
-    }
-    model_name: Optional[str] = Field(
-        default_factory=lambda: os.getenv("UIPATH_MODEL_NAME", "gpt-4o-2024-08-06"),
-        alias="model",
-    )
-    settings: Optional[UiPathClientSettings] = None
-    client_id: Optional[str] = Field(
-        default_factory=lambda: os.getenv("UIPATH_CLIENT_ID")
-    )
-    client_secret: Optional[str] = Field(
-        default_factory=lambda: os.getenv("UIPATH_CLIENT_SECRET")
-    )
-    base_url: Optional[str] = Field(
-        default_factory=lambda data: getattr(data["settings"], "base_url", None)
-        or os.getenv("UIPATH_BASE_URL")
-        or get_from_uipath_url(),
-        alias="azure_endpoint",
-    )
-    access_token: Optional[str] = Field(
-        default_factory=lambda data: (
-            getattr(data["settings"], "access_token", None)
-            or os.getenv("UIPATH_ACCESS_TOKEN")  # Environment variable
-            or os.getenv("UIPATH_SERVICE_TOKEN")  # Environment variable
-            or get_uipath_token_header(
-                UiPathClientFactorySettings(
-                    UIPATH_BASE_URL=data["base_url"],
-                    UIPATH_CLIENT_ID=data["client_id"],
-                    UIPATH_CLIENT_SECRET=data["client_secret"],
-                )
-            )  # Get service token from UiPath
-        )
-    )
-    org_id: Any = Field(
-        default_factory=lambda data: getattr(data["settings"], "org_id", None)
-        or os.getenv("UIPATH_ORGANIZATION_ID", "")
-    )
-    tenant_id: Any = Field(
-        default_factory=lambda data: getattr(data["settings"], "tenant_id", None)
-        or os.getenv("UIPATH_TENANT_ID", "")
-    )
-    requesting_product: Any = Field(
-        default_factory=lambda data: getattr(
-            data["settings"], "requesting_product", None
-        )
-        or os.getenv("UIPATH_REQUESTING_PRODUCT", "")
-    )
-    requesting_feature: Any = Field(
-        default_factory=lambda data: getattr(
-            data["settings"], "requesting_feature", None
-        )
-        or os.getenv("UIPATH_REQUESTING_FEATURE", "")
-    )
-    default_request_timeout: Any = Field(
-        default_factory=lambda data: float(
-            getattr(data["settings"], "timeout_seconds", None)
-            or os.getenv("UIPATH_TIMEOUT_SECONDS", "120")
-        ),
-        alias="timeout",
-    )
-
-    openai_api_version: Optional[str] = Field(
-        default_factory=lambda: os.getenv("OPENAI_API_VERSION", "2024-08-01-preview"),
-        alias="api_version",
-    )
-    include_account_id: bool = False
-    temperature: Optional[float] = 0.0
-    max_tokens: Optional[int] = 1000
-    frequency_penalty: Optional[float] = None
-    presence_penalty: Optional[float] = None
-
-    logger: Optional[logging.Logger] = None
-    max_retries: Optional[int] = 5
-    base_delay: float = 5.0
-    max_delay: float = 60.0
-
-    _url: Optional[str] = None
-    _auth_headers: Optional[Dict[str, str]] = None
-
-    # required to instantiate AzureChatOpenAI subclasses
-    azure_endpoint: Optional[str] = Field(
-        default="placeholder", description="Bypassed Azure endpoint"
-    )
-    openai_api_key: Optional[SecretStr] = Field(
-        default=SecretStr("placeholder"), description="Bypassed API key"
-    )
-    # required to instatiate ChatAnthropic subclasses (will be needed when passthrough is implemented for Anthropic models)
-    stop_sequences: Optional[List[str]] = Field(
-        default=None, description="Bypassed stop sequence"
-    )
-
-    def _request(
-        self, url: str, request_body: Dict[str, Any], headers: Dict[str, str]
-    ) -> Dict[str, Any]:
-        """Run an asynchronous call to the LLM."""
-        # if self.logger:
-        #     self.logger.info(f"Completion request: {request_body['messages'][:2]}")
-        with httpx.Client(
-            event_hooks={
-                "request": [self._log_request_duration],
-                "response": [self._log_response_duration],
-            }
-        ) as client:
-            response = client.post(
-                url,
-                headers=headers,
-                json=request_body,
-                timeout=self.default_request_timeout,
-            )
-
-            # Handle HTTP errors and map them to OpenAI exceptions
-            try:
-                response.raise_for_status()
-            except httpx.HTTPStatusError as err:
-                if self.logger:
-                    self.logger.error(
-                        "Error querying UiPath: %s (%s)",
-                        err.response.reason_phrase,
-                        err.response.status_code,
-                        extra={
-                            "ActionName": self.settings.action_name,
-                            "ActionId": self.settings.action_id,
-                        }
-                        if self.settings
-                        else None,
-                    )
-                raise self._make_status_error_from_response(err.response) from err
-
-            return response.json()
-
-    def _call(
-        self, url: str, request_body: Dict[str, Any], headers: Dict[str, str]
-    ) -> Dict[str, Any]:
-        """Run a synchronous call with retries to LLM"""
-        if self.max_retries is None:
-            return self._request(url, request_body, headers)
-
-        retryer = Retrying(
-            stop=stop_after_attempt(self.max_retries),
-            wait=wait_exponential_jitter(
-                initial=self.base_delay,
-                max=self.max_delay,
-                jitter=1.0,
-            ),
-            retry=retry_if_exception_type(
-                (openai.RateLimitError, httpx.TimeoutException)
-            ),
-            reraise=True,
-            before_sleep=before_sleep_log(self.logger, logging.WARNING)
-            if self.logger is not None
-            else None,
-        )
-
-        try:
-            return retryer(self._request, url, request_body, headers)
-        except openai.APIStatusError as err:
-            if self.logger:
-                self.logger.error(
-                    "Failed querying LLM after retries: %s",
-                    err,
-                    extra={
-                        "ActionName": self.settings.action_name,
-                        "ActionId": self.settings.action_id,
-                    }
-                    if self.settings
-                    else None,
-                )
-            raise err
-
-    async def _arequest(
-        self, url: str, request_body: Dict[str, Any], headers: Dict[str, str]
-    ) -> Dict[str, Any]:
-        # if self.logger:
-        #     self.logger.info(f"Completion request: {request_body['messages'][:2]}")
-        async with httpx.AsyncClient(
-            event_hooks={
-                "request": [self._alog_request_duration],
-                "response": [self._alog_response_duration],
-            }
-        ) as client:
-            response = await client.post(
-                url,
-                headers=headers,
-                json=request_body,
-                timeout=self.default_request_timeout,
-            )
-            # Handle HTTP errors and map them to OpenAI exceptions
-            try:
-                response.raise_for_status()
-            except httpx.HTTPStatusError as err:
-                if self.logger:
-                    self.logger.error(
-                        "Error querying LLM: %s (%s)",
-                        err.response.reason_phrase,
-                        err.response.status_code,
-                        extra={
-                            "ActionName": self.settings.action_name,
-                            "ActionId": self.settings.action_id,
-                        }
-                        if self.settings
-                        else None,
-                    )
-                raise self._make_status_error_from_response(err.response) from err
-
-            return response.json()
-
-    async def _acall(
-        self, url: str, request_body: Dict[str, Any], headers: Dict[str, str]
-    ) -> Dict[str, Any]:
-        """Run an asynchronous call with retries to the LLM."""
-        if self.max_retries is None:
-            return await self._arequest(url, request_body, headers)
-
-        retryer = AsyncRetrying(
-            stop=stop_after_attempt(self.max_retries),
-            wait=wait_exponential_jitter(
-                initial=self.base_delay,
-                max=self.max_delay,
-                jitter=1.0,
-            ),
-            retry=retry_if_exception_type(
-                (openai.RateLimitError, httpx.TimeoutException)
-            ),
-            reraise=True,
-            before_sleep=before_sleep_log(self.logger, logging.WARNING)
-            if self.logger is not None
-            else None,
-        )
-
-        try:
-            response: Any = await retryer(self._arequest, url, request_body, headers)
-            if self.logger:
-                self.logger.info(
-                    f"[uipath_langchain_client] Finished retryer after {retryer.statistics['attempt_number'] - 1} retries",
-                    extra={
-                        "retry": f"{retryer.statistics['attempt_number'] - 1}",
-                        "ActionName": self.settings.action_name,
-                        "ActionId": self.settings.action_id,
-                    }
-                    if self.settings
-                    else {
-                        "retry": f"{retryer.statistics['attempt_number'] - 1}",
-                    },
-                )
-            return response
-        except openai.APIStatusError as err:
-            if self.logger:
-                self.logger.error(
-                    "[uipath_langchain_client] Failed querying LLM after retries: %s",
-                    err,
-                    extra={
-                        "reason": err.message,
-                        "statusCode": err.status_code,
-                        "ActionName": self.settings.action_name,
-                        "ActionId": self.settings.action_id,
-                    }
-                    if self.settings
-                    else {
-                        "reason": err.message,
-                        "statusCode": err.status_code,
-                    },
-                )
-            raise err
-
-    def _make_status_error_from_response(
-        self,
-        response: httpx.Response,
-    ) -> openai.APIStatusError:
-        """Function reproduced from openai._client to handle UiPath errors."""
-        if response.is_closed and not response.is_stream_consumed:
-            # We can't read the response body as it has been closed
-            # before it was read. This can happen if an event hook
-            # raises a status error.
-            body = None
-            err_msg = f"Error code: {response.status_code}"
-        else:
-            err_text = response.text.strip()
-            body = err_text
-
-            try:
-                body = json.loads(err_text)
-                err_msg = f"Error code: {response.status_code} - {body}"
-            except Exception:
-                err_msg = err_text or f"Error code: {response.status_code}"
-
-        return self._make_status_error(err_msg, body=body, response=response)
-
-    def _make_status_error(
-        self,
-        err_msg: str,
-        *,
-        body: object,
-        response: httpx.Response,
-    ) -> openai.APIStatusError:
-        """Function reproduced from openai._client to handle UiPath errors."""
-        data = body.get("error", body) if isinstance(body, Mapping) else body
-        if response.status_code == 400:
-            return openai.BadRequestError(err_msg, response=response, body=data)
-
-        if response.status_code == 401:
-            return openai.AuthenticationError(err_msg, response=response, body=data)
-
-        if response.status_code == 403:
-            return openai.PermissionDeniedError(err_msg, response=response, body=data)
-
-        if response.status_code == 404:
-            return openai.NotFoundError(err_msg, response=response, body=data)
-
-        if response.status_code == 409:
-            return openai.ConflictError(err_msg, response=response, body=data)
-
-        if response.status_code == 422:
-            return openai.UnprocessableEntityError(
-                err_msg, response=response, body=data
-            )
-
-        if response.status_code == 429:
-            return openai.RateLimitError(err_msg, response=response, body=data)
-
-        if response.status_code >= 500:
-            return openai.InternalServerError(err_msg, response=response, body=data)
-        return openai.APIStatusError(err_msg, response=response, body=data)
-
-    def _log_request_duration(self, request: httpx.Request):
-        """Log the start time of the request."""
-        if self.logger:
-            request.extensions["start_time"] = time.monotonic()
-
-    def _log_response_duration(self, response: httpx.Response):
-        """Log the duration of the request."""
-        if self.logger:
-            start_time = response.request.extensions.get("start_time")
-            if start_time:
-                duration = time.monotonic() - start_time
-                type = "embedding"
-                if not isinstance(self, Embeddings):
-                    type = "normalized" if self.is_normalized else "completion"
-                self.logger.info(
-                    f"[uipath_langchain_client] Request to {response.request.url} took {duration:.2f} seconds.",
-                    extra={
-                        "requestUrl": f"{response.request.url}",
-                        "duration": f"{duration:.2f}",
-                        "type": type,
-                        "ActionName": self.settings.action_name,
-                        "ActionId": self.settings.action_id,
-                    }
-                    if self.settings
-                    else {
-                        "requestUrl": f"{response.request.url}",
-                        "duration": f"{duration:.2f}",
-                        "type": type,
-                    },
-                )
-
-    async def _alog_request_duration(self, request: httpx.Request):
-        """Log the start time of the request."""
-        self._log_request_duration(request)
-
-    async def _alog_response_duration(self, response: httpx.Response):
-        """Log the duration of the request."""
-        self._log_response_duration(response)
-
-    @property
-    def _llm_type(self) -> str:
-        """Get the type of language model used by this chat model. Used for logging purposes only."""
-        return "uipath"
-
-    @property
-    def _identifying_params(self) -> Dict[str, Any]:
-        return {
-            "url": self.url,
-            "model": self.model_name,
-            "temperature": self.temperature,
-            "max_tokens": self.max_tokens,
-            "frequency_penalty": self.frequency_penalty,
-            "presence_penalty": self.presence_penalty,
-        }
-
-    def _prepare_url(self, url: str) -> httpx.URL:
-        return httpx.URL(self.url)
-
-    def _build_headers(self, options, retries_taken: int = 0) -> httpx.Headers:
-        return httpx.Headers(self.auth_headers)
-
-    @property
-    def url(self) -> str:
-        if not self._url:
-            self._url = (
-                f"{self.base_url}/{self.org_id}/{self.tenant_id}/{self.endpoint}"
-            )
-        return self._url
-
-    @property
-    def endpoint(self) -> str:
-        raise NotImplementedError(
-            "The endpoint property is not implemented for this class."
-        )
-
-    @property
-    def auth_headers(self) -> Dict[str, str]:
-        if not self._auth_headers:
-            self._auth_headers = {
-                **self.default_headers,  # type: ignore
-                "Authorization": f"Bearer {self.access_token}",
-                "X-UiPath-LlmGateway-RequestingProduct": self.requesting_product,
-                "X-UiPath-LlmGateway-RequestingFeature": self.requesting_feature,
-                "X-UiPath-LlmGateway-TimeoutSeconds": str(self.default_request_timeout),
-            }
-            if self.is_normalized and self.model_name:
-                self._auth_headers["X-UiPath-LlmGateway-NormalizedApi-ModelName"] = (
-                    self.model_name
-                )
-            if self.include_account_id:
-                self._auth_headers["x-uipath-internal-accountid"] = self.org_id
-                self._auth_headers["x-uipath-internal-tenantid"] = self.tenant_id
-        return self._auth_headers
-
-    def _get_llm_string(self, stop: Optional[list[str]] = None, **kwargs: Any) -> str:
-        serialized_repr = getattr(self, "_serialized", self.model_dump())
-        _cleanup_llm_representation(serialized_repr, 1)
-        kwargs = serialized_repr.get("kwargs", serialized_repr)
-        for key in [
-            "base_url",
-            "access_token",
-            "client_id",
-            "client_secret",
-            "org_id",
-            "tenant_id",
-            "requesting_product",
-            "requesting_feature",
-            "azure_endpoint",
-            "openai_api_version",
-            "openai_api_key",
-            "default_request_timeout",
-            "max_retries",
-            "base_delay",
-            "max_delay",
-            "logger",
-            "settings",
-        ]:
-            if key in kwargs:
-                kwargs.pop(key, None)
-        llm_string = json.dumps(serialized_repr, sort_keys=True)
-        return llm_string
-
-    @property
-    def is_normalized(self) -> bool:
-        return False

uipath_langchain/utils/_settings.py

@@ -1,91 +0,0 @@
-# mypy: disable-error-code="syntax"
-import os
-from enum import Enum
-from typing import Any, Optional
-
-import httpx
-from pydantic import Field
-from pydantic_settings import BaseSettings
-
-
-class UiPathCachedPathsSettings(BaseSettings):
-    cached_completion_db: str = Field(
-        default=os.path.join(
-            os.path.dirname(__file__), "tests", "tests_uipath_cache.db"
-        ),
-        alias="CACHED_COMPLETION_DB",
-    )
-    cached_embeddings_dir: str = Field(
-        default=os.path.join(os.path.dirname(__file__), "tests", "cached_embeddings"),
-        alias="CACHED_EMBEDDINGS_DIR",
-    )
-
-
-uipath_cached_paths_settings = UiPathCachedPathsSettings()
-uipath_token_header: Optional[str] = None
-
-
-class UiPathClientFactorySettings(BaseSettings):
-    base_url: str = Field(default="", alias="UIPATH_BASE_URL")
-    client_id: str = Field(default="", alias="UIPATH_CLIENT_ID")
-    client_secret: str = Field(default="", alias="UIPATH_CLIENT_SECRET")
-
-
-class UiPathClientSettings(BaseSettings):
-    access_token: str = Field(default_factory=lambda: get_uipath_token_header())
-    base_url: str = Field(default="", alias="UIPATH_BASE_URL")
-    org_id: str = Field(default="", alias="UIPATH_ORGANIZATION_ID")
-    tenant_id: str = Field(default="", alias="UIPATH_TENANT_ID")
-    requesting_product: str = Field(default="", alias="UIPATH_REQUESTING_PRODUCT")
-    requesting_feature: str = Field(default="", alias="UIPATH_REQUESTING_FEATURE")
-    timeout_seconds: str = Field(default="120", alias="UIPATH_TIMEOUT_SECONDS")
-    action_name: str = Field(default="DefaultActionName", alias="UIPATH_ACTION_NAME")
-    action_id: str = Field(default="DefaultActionId", alias="UIPATH_ACTION_ID")
-
-
-class UiPathEndpoints(Enum):
-    NORMALIZED_COMPLETION_ENDPOINT = "llmgateway_/api/chat/completions"
-    PASSTHROUGH_COMPLETION_ENDPOINT = "llmgateway_/openai/deployments/{model}/chat/completions?api-version={api_version}"
-    EMBEDDING_ENDPOINT = (
-        "llmgateway_/openai/deployments/{model}/embeddings?api-version={api_version}"
-    )
-
-
-def get_uipath_token_header(
-    settings: Any = None,
-) -> str:
-    global uipath_token_header
-    if not uipath_token_header:
-        settings = settings or UiPathClientFactorySettings()
-        url_get_token = f"{settings.base_url}/identity_/connect/token"
-        token_credentials = dict(
-            client_id=settings.client_id,
-            client_secret=settings.client_secret,
-            grant_type="client_credentials",
-        )
-        with httpx.Client() as client:
-            res = client.post(url_get_token, data=token_credentials)
-            res_json = res.json()
-            uipath_token_header = res_json.get("access_token")
-
-    return uipath_token_header or ""
-
-
-async def get_token_header_async(
-    settings: Any = None,
-) -> str:
-    global uipath_token_header
-    if not uipath_token_header:
-        settings = settings or UiPathClientFactorySettings()
-        url_get_token = f"{settings.base_url}/identity_/connect/token"
-        token_credentials = dict(
-            client_id=settings.client_id,
-            client_secret=settings.client_secret,
-            grant_type="client_credentials",
-        )
-
-        with httpx.Client() as client:
-            res_json = client.post(url_get_token, data=token_credentials).json()
-            uipath_token_header = res_json.get("access_token")
-
-    return uipath_token_header or ""

uipath_langchain/utils/_sleep_policy.py

@@ -1,41 +0,0 @@
-import logging
-from typing import Callable
-
-from tenacity import (
-    RetryCallState,
-    _utils,
-)
-
-
-def before_sleep_log(
-    logger: "logging.Logger",
-    log_level: int,
-    exc_info: bool = False,
-) -> Callable[["RetryCallState"], None]:
-    """Before call strategy that logs to some logger the attempt."""
-
-    def log_it(retry_state: "RetryCallState") -> None:
-        if retry_state.outcome is None:
-            raise RuntimeError("log_it() called before outcome was set")
-
-        if retry_state.next_action is None:
-            raise RuntimeError("log_it() called before next_action was set")
-
-        if retry_state.outcome.failed:
-            ex = retry_state.outcome.exception()
-            verb, value = "raised", f"{ex.__class__.__name__}: {ex}"
-        else:
-            verb, value = "returned", retry_state.outcome.result()
-
-        if retry_state.fn is None:
-            fn_name = "<unknown>"
-        else:
-            fn_name = _utils.get_callback_name(retry_state.fn)
-
-        logger.log(
-            log_level,
-            f"Retrying #{retry_state.attempt_number} {fn_name} in {retry_state.next_action.sleep} seconds as it {verb} {value}.",
-            {"retries": f"{retry_state.attempt_number}"},
-        )
-
-    return log_it