uipath-langchain 0.0.147__py3-none-any.whl → 0.0.148__py3-none-any.whl

uipath_langchain/_utils/_request_mixin.py

@@ -17,7 +17,11 @@ from tenacity import (
     stop_after_attempt,
     wait_exponential_jitter,
 )
-from uipath._cli._runtime._contracts import UiPathErrorCategory, UiPathRuntimeError
+from uipath._cli._runtime._contracts import (
+    UiPathErrorCategory,
+    UiPathErrorCode,
+    UiPathRuntimeError,
+)
 from uipath._utils._ssl_context import get_httpx_client_kwargs
 
 from uipath_langchain._cli._runtime._exception import (
@@ -59,7 +63,7 @@ def _get_access_token(data):
         return get_uipath_token_header(settings)
     except ValidationError:
         raise UiPathRuntimeError(
-            code="AUTHENTICATION_REQUIRED",
+            UiPathErrorCode.AUTHENTICATION_REQUIRED,
             title="Authorization required",
             detail="Authorization required. Please run uipath auth",
             category=UiPathErrorCategory.USER,

{uipath_langchain-0.0.147.dist-info → uipath_langchain-0.0.148.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.147
+Version: 0.0.148
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
@@ -26,7 +26,7 @@ Requires-Dist: openai>=1.65.5
 Requires-Dist: openinference-instrumentation-langchain>=0.1.50
 Requires-Dist: pydantic-settings>=2.6.0
 Requires-Dist: python-dotenv>=1.0.1
-Requires-Dist: uipath<2.2.0,>=2.1.110
+Requires-Dist: uipath<2.2.0,>=2.1.123
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.147.dist-info → uipath_langchain-0.0.148.dist-info}/RECORD

@@ -26,7 +26,7 @@ uipath_langchain/_tracing/__init__.py,sha256=C2dRvQ2ynxCmyICgE-rJHimWKEcFRME_o9g
 uipath_langchain/_tracing/_instrument_traceable.py,sha256=8f9FyAKWE6kH1N8ErbpwqZHAzNjGwbLjQn7jdX5yAgA,4343
 uipath_langchain/_tracing/_utils.py,sha256=r_fiSk3HDDAcePY_UbbEYiSbNqzn5gFeMPYBDvGrFx0,902
 uipath_langchain/_utils/__init__.py,sha256=-w-4TD9ZnJDCpj4VIPXhJciukrmDJJbmnOFnhAkAaEU,81
-uipath_langchain/_utils/_request_mixin.py,sha256=_drxHTRpfyVn3g3ppKgn466EBaUWH83qyeGKLY41CGY,20142
+uipath_langchain/_utils/_request_mixin.py,sha256=AqdXUuV8hHNJYUAmAoBA1sptK52H46-QcgutVPyUfao,20185
 uipath_langchain/_utils/_settings.py,sha256=2fExMQJ88YptfldmzMfZIpsx-m1gfMkeYGf5t6KIe0A,3084
 uipath_langchain/_utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
 uipath_langchain/agent/react/__init__.py,sha256=XXplWNiD9XCxMVVyE0RL8tOwJjkP9ZKU6mFR5Em0ONk,314
@@ -53,12 +53,10 @@ uipath_langchain/embeddings/__init__.py,sha256=QICtYB58ZyqFfDQrEaO8lTEgAU5NuEKlR
 uipath_langchain/embeddings/embeddings.py,sha256=45gKyb6HVKigwE-0CXeZcAk33c0mteaEdPGa8hviqcw,4339
 uipath_langchain/retrievers/__init__.py,sha256=rOn7PyyHgZ4pMnXWPkGqmuBmx8eGuo-Oyndo7Wm9IUU,108
 uipath_langchain/retrievers/context_grounding_retriever.py,sha256=YLCIwy89LhLnNqcM0YJ5mZoeNyCs5UiKD3Wly8gnW1E,2239
-uipath_langchain/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-uipath_langchain/tools/preconfigured.py,sha256=SyvrLrM1kezZxVVytgScVO8nBfVYfFGobWjY7erzsYU,7490
 uipath_langchain/vectorstores/__init__.py,sha256=w8qs1P548ud1aIcVA_QhBgf_jZDrRMK5Lono78yA8cs,114
 uipath_langchain/vectorstores/context_grounding_vectorstore.py,sha256=E0iuDBMAOl50Bdhl3YxywR0CngH1I99mkmfMh3byMFY,8396
-uipath_langchain-0.0.147.dist-info/METADATA,sha256=IxSINnczz6chaAcdHlkwSzyLdGRN04PKd0MXY8m2fRg,4276
-uipath_langchain-0.0.147.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.147.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.147.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.147.dist-info/RECORD,,
+uipath_langchain-0.0.148.dist-info/METADATA,sha256=ucOXQNU19PUpVFPtiK3VrjAkGtx-jgXC8RkLtZspgoA,4276
+uipath_langchain-0.0.148.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_langchain-0.0.148.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
+uipath_langchain-0.0.148.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.0.148.dist-info/RECORD,,

uipath_langchain/tools/preconfigured.py

@@ -1,220 +0,0 @@
-import json
-import logging
-from typing import Any, Iterable, Optional, Type
-
-import httpx
-from jsonschema_pydantic import jsonschema_to_pydantic as create_model  # type: ignore
-from langchain_core.caches import BaseCache
-from langchain_core.runnables.utils import Output
-from langchain_core.tools import BaseTool, StructuredTool
-from langgraph.types import interrupt
-from pydantic import BaseModel
-from uipath import UiPath
-from uipath.agent.models.agent import (
-    AgentEscalationChannel,
-    AgentEscalationResourceConfig,
-    AgentIntegrationToolParameter,
-    AgentIntegrationToolResourceConfig,
-    AgentProcessToolResourceConfig,
-    AgentResourceConfig,
-    LowCodeAgentDefinition,
-)
-from uipath.models import CreateAction, InvokeProcess
-from uipath.models.connections import ConnectionTokenType
-
-logger = logging.getLogger(__name__)
-
-
-def create_process_tool(resource: AgentProcessToolResourceConfig) -> Iterable[BaseTool]:
-    async def process(**kwargs) -> BaseModel:
-        return interrupt(
-            InvokeProcess(
-                name=resource.name,
-                input_arguments=kwargs,
-                process_folder_path=resource.properties.folder_path,
-            )
-        )
-
-    input_schema = create_model(resource.input_schema)
-
-    class ProcessTool(StructuredTool):
-        @property
-        def OutputType(self) -> type[Output]:
-            return create_model(resource.output_schema)
-
-    yield ProcessTool(
-        name=resource.name,
-        args_schema=input_schema,
-        description=resource.description,
-        coroutine=process,
-    )
-
-
-def create_escalation_tool_from_channel(channel: AgentEscalationChannel) -> BaseTool:
-    async def escalate(**kwargs) -> BaseModel:
-        recipients = channel.recipients
-        if len(recipients) > 1:
-            logger.warning(
-                "Received more than one recipient. Defaulting to first recipient."
-            )
-        assignee = recipients[0].value if recipients else None
-        return interrupt(
-            CreateAction(
-                title=channel.description,
-                data=kwargs,
-                assignee=assignee,
-                app_name=channel.properties.app_name,
-                app_folder_path=None,  # Channels specify folder name but not folder path.
-                app_folder_key=channel.properties.resource_key,
-                app_key=channel.properties.resource_key,
-                app_version=channel.properties.app_version,
-            )
-        )
-
-    input_schema = create_model(channel.input_schema)
-
-    class EscalationTool(StructuredTool):
-        @property
-        def OutputType(self) -> type[Output]:
-            return create_model(channel.output_schema)
-
-    return EscalationTool(
-        name=channel.name,
-        args_schema=input_schema,
-        description=channel.description,
-        coroutine=escalate,
-    )
-
-
-def create_escalation_tool(
-    resource: AgentEscalationResourceConfig,
-) -> Iterable[BaseTool]:
-    for channel in resource.channels:
-        yield create_escalation_tool_from_channel(channel)
-
-
-METHOD_MAP = {"GETBYID": "GET"}
-
-
-def build_query_params(parameters: list[AgentIntegrationToolParameter]):
-    query_params = [
-        x for x in parameters if x.field_location == "query" and x.value is not None
-    ]
-    if query_params:
-        return "?" + "&".join(f"{q.name}={q.value}" for q in query_params)
-    return ""
-
-
-def filter_query_params(
-    kwargs: dict[str, Any], parameters: list[AgentIntegrationToolParameter]
-):
-    query_params = {x.name for x in parameters if x.field_location == "query"}
-    non_query_params = {x.name for x in parameters if x.field_location != "query"}
-    fields_to_ignore = query_params - non_query_params
-    return {k: v for k, v in kwargs.items() if k not in fields_to_ignore}
-
-
-def create_integration_tool(
-    resource: AgentIntegrationToolResourceConfig,
-) -> Iterable[BaseTool]:
-    async def integration(**kwargs) -> BaseModel:
-        uipath = UiPath()
-        remote_connection = await uipath.connections.retrieve_async(
-            resource.properties.connection.id
-        )
-        token = await uipath.connections.retrieve_token_async(
-            resource.properties.connection.id, ConnectionTokenType.BEARER
-        )
-        tool_url = f"{remote_connection.api_base_uri}/v3/element/instances/{remote_connection.element_instance_id}{resource.properties.tool_path}"
-        tool_url = f"{tool_url}{build_query_params(resource.properties.parameters)}"
-        tool_url = tool_url.format(**kwargs)
-
-        authorization = f"{token.token_type} {token.access_token}"
-        method = METHOD_MAP.get(resource.properties.method, resource.properties.method)
-        response = await httpx.AsyncClient().request(
-            method,
-            tool_url,
-            headers={"Authorization": authorization},
-            content=json.dumps(
-                filter_query_params(kwargs, resource.properties.parameters)
-            ),
-        )
-        return response.json()
-
-    input_schema = create_model(resource.input_schema)
-
-    class IntegrationTool(StructuredTool):
-        @property
-        def OutputType(self) -> type[Output]:
-            return create_model({})
-
-    yield IntegrationTool(
-        name=resource.name,
-        args_schema=input_schema,
-        description=resource.description,
-        coroutine=integration,
-    )
-
-
-def create_cached_wrapper_from_tool(
-    wrapped: BaseTool, cache: Optional[BaseCache]
-) -> BaseTool:
-    if cache is None:
-        return wrapped
-    else:
-
-        async def cached_invocation(**kwargs) -> BaseModel:
-            namespace = f"{wrapped.name}.tool_invoke"
-            key = str(kwargs)
-            cached = cache.lookup(namespace, key)
-            if cached:
-                return cached[0]
-            response = await wrapped.ainvoke(input=kwargs)
-            cache.update(namespace, key, [response])
-            return response
-
-        input_schema = wrapped.args_schema
-
-        class CachedTool(StructuredTool):
-            OutputType: Type[BaseModel] = wrapped.OutputType
-
-        return CachedTool(
-            name=wrapped.name,
-            args_schema=input_schema,
-            description=wrapped.description,
-            coroutine=cached_invocation,
-        )
-
-
-def create_cached_wrapper(
-    tools: Iterable[BaseTool], cache: Optional[BaseCache]
-) -> Iterable[BaseTool]:
-    for wrapped in tools:
-        yield create_cached_wrapper_from_tool(wrapped, cache)
-
-
-def create_resource_tool(
-    resource: AgentResourceConfig, cache: Optional[BaseCache] = None
-) -> Iterable[BaseTool]:
-    match resource:
-        case AgentProcessToolResourceConfig():
-            return create_cached_wrapper(create_process_tool(resource), cache)
-        case AgentIntegrationToolResourceConfig():
-            return create_cached_wrapper(create_integration_tool(resource), cache)
-        case AgentEscalationResourceConfig():
-            return create_cached_wrapper(create_escalation_tool(resource), cache)
-        case _:
-            raise NotImplementedError()
-
-
-def safe_extract_tools(
-    agent_definition: LowCodeAgentDefinition, cache: Optional[BaseCache] = None
-) -> list[BaseTool]:
-    tools = []
-    for resource in agent_definition.resources:
-        try:
-            for structured_tool in create_resource_tool(resource, cache):
-                tools.append(structured_tool)
-        except NotImplementedError:
-            logger.warning(f"Unable to convert {resource.name} into a tool.")
-    return tools