uipath-langchain 0.0.132__py3-none-any.whl → 0.0.133__py3-none-any.whl

uipath_langchain/tools/preconfigured.py

@@ -0,0 +1,191 @@
+import json
+import logging
+from typing import 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 (
+    AgentDefinition,
+    AgentEscalationChannel,
+    AgentEscalationResourceConfig,
+    AgentIntegrationToolResourceConfig,
+    AgentProcessToolResourceConfig,
+    AgentResourceConfig,
+)
+from uipath.models import CreateAction, InvokeProcess
+
+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)
+
+
+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
+        )
+        tool_url = f"{remote_connection.api_base_uri}/v3/element/instances/{remote_connection.element_instance_id}{resource.properties.tool_path}"
+
+        response = await httpx.AsyncClient().request(
+            resource.properties.method,
+            tool_url,
+            headers={"Authorization": f"Bearer {token.access_token}"},
+            content=json.dumps(kwargs),
+        )
+        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: AgentDefinition, 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

{uipath_langchain-0.0.132.dist-info → uipath_langchain-0.0.133.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.132
+Version: 0.0.133
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.27.0
+Requires-Dist: jsonschema-pydantic>=0.6
 Requires-Dist: langchain-community>=0.3.21
 Requires-Dist: langchain-core>=0.3.34
 Requires-Dist: langchain-openai>=0.3.3
@@ -25,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.56
+Requires-Dist: uipath<2.2.0,>=2.1.60
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.132.dist-info → uipath_langchain-0.0.133.dist-info}/RECORD

@@ -30,10 +30,12 @@ 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=Ucl9mta_su66j-5uOC-vZzyc3V2-Em6q9WO1qsmQv48,6291
 uipath_langchain/vectorstores/__init__.py,sha256=w8qs1P548ud1aIcVA_QhBgf_jZDrRMK5Lono78yA8cs,114
 uipath_langchain/vectorstores/context_grounding_vectorstore.py,sha256=TncIXG-YsUlO0R5ZYzWsM-Dj1SVCZbzmo2LraVxXelc,9559
-uipath_langchain-0.0.132.dist-info/METADATA,sha256=ta5yg3ODDXTdagrZVgeevO7wzwjwDeIIR3dAC_wmctM,4235
-uipath_langchain-0.0.132.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.132.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.132.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.132.dist-info/RECORD,,
+uipath_langchain-0.0.133.dist-info/METADATA,sha256=zcSdl4I5iJsBi0jOf7IUUprBv39KfQZyrM1EzVH1OCQ,4275
+uipath_langchain-0.0.133.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_langchain-0.0.133.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
+uipath_langchain-0.0.133.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.0.133.dist-info/RECORD,,