uipath-langchain 0.0.132__tar.gz → 0.0.133__tar.gz

{uipath_langchain-0.0.132 → uipath_langchain-0.0.133}/PKG-INFO

@@ -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 → uipath_langchain-0.0.133}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "uipath-langchain"
-version = "0.0.132"
+version = "0.0.133"
 description = "UiPath Langchain"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 dependencies = [
-    "uipath>=2.1.56, <2.2.0",
+    "uipath>=2.1.60, <2.2.0",
     "langgraph>=0.5.0, <0.7.0",
     "langchain-core>=0.3.34",
     "langgraph-checkpoint-sqlite>=2.0.3",
@@ -17,6 +17,7 @@ dependencies = [
     "httpx>=0.27.0",
     "openai>=1.65.5",
     "openinference-instrumentation-langchain>=0.1.50",
+    "jsonschema-pydantic>=0.6",
 ]
 classifiers = [
     "Development Status :: 3 - Alpha",

{uipath_langchain-0.0.132 → uipath_langchain-0.0.133}/samples/calculator-agent/uv.lock

@@ -285,7 +285,7 @@ requires-dist = [
     { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.11.1" },
     { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.6.1" },
     { name = "uipath", specifier = ">=2.1.54" },
-    { name = "uipath-langchain", editable = "../../" },
+    { name = "uipath-langchain", directory = "../../" },
 ]
 provides-extras = ["dev"]
 
@@ -557,7 +557,7 @@ name = "exceptiongroup"
 version = "1.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/a65090624ecf468cdca03533906e7c69ed7588582240cfe7cc9e770b50eb/exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88", size = 29749 }
 wheels = [
@@ -2640,7 +2640,7 @@ wheels = [
 
 [[package]]
 name = "uipath"
-version = "2.1.54"
+version = "2.1.56"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "azure-monitor-opentelemetry" },
@@ -2658,15 +2658,15 @@ dependencies = [
     { name = "tomli" },
     { name = "truststore" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e8/4f/5e34bde81c3ccd98a937101c4cd069901cb9f0158b53dea0f58bd4f908ec/uipath-2.1.54.tar.gz", hash = "sha256:bc3bedea41fa4517495eba6a14a6e794d8e93740ee1dd229f417ee0e325c367c", size = 2001743 }
+sdist = { url = "https://files.pythonhosted.org/packages/73/bd/058b5f5c1e8b41db0c1f4fd3d8eb73c88eb9ead4edb538ae7b2304fa65e1/uipath-2.1.56.tar.gz", hash = "sha256:3afdcf7ebab02d88115d6700d93da19a7cf50b93123a3faf1755c25e6adffcd3", size = 2006943 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/94/ce/dc6c7e8b20474761ec17c7e8fcfd3619880c921bcfbe3df3d1f6890c71d6/uipath-2.1.54-py3-none-any.whl", hash = "sha256:379105de535f1c3922794fb14574790aa7c1b4b63256ebcff7d28f486ef34df3", size = 228190 },
+    { url = "https://files.pythonhosted.org/packages/17/0e/58e805e67788859a4a6811a224f723436990058ca085905b2f3b0dd6aa3a/uipath-2.1.56-py3-none-any.whl", hash = "sha256:0ea1c738da38c2c808bf03d4590cd715cd187187f2972e5c5f38d1034ad84245", size = 228414 },
 ]
 
 [[package]]
 name = "uipath-langchain"
-version = "0.0.130"
-source = { editable = "../../" }
+version = "0.0.132"
+source = { directory = "../../" }
 dependencies = [
     { name = "httpx" },
     { name = "langchain" },
@@ -2695,7 +2695,7 @@ requires-dist = [
     { name = "openinference-instrumentation-langchain", specifier = ">=0.1.50" },
     { name = "pydantic-settings", specifier = ">=2.6.0" },
     { name = "python-dotenv", specifier = ">=1.0.1" },
-    { name = "uipath", specifier = ">=2.1.49,<2.2.0" },
+    { name = "uipath", specifier = ">=2.1.56,<2.2.0" },
     { name = "uipath-langchain", marker = "extra == 'langchain'", specifier = ">=0.0.2" },
 ]
 provides-extras = ["langchain"]

uipath_langchain-0.0.133/src/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.133/tests/tools/__init__.py

@@ -0,0 +1 @@
+# Init file to make the tests directory a package

uipath_langchain-0.0.133/tests/tools/conftest.py

@@ -0,0 +1,72 @@
+import os
+from contextlib import contextmanager
+
+
+def get_file_path(file_name: str) -> str:
+    """
+    Get the path to a mock file, checking multiple possible locations.
+
+    Args:
+        file_name: Name of the file to locate
+
+    Returns:
+        Absolute path to the file
+    """
+    if os.path.isfile(f"mocks/{file_name}"):
+        return os.path.abspath(f"mocks/{file_name}")
+    else:
+        return os.path.abspath(f"tests/tools/mocks/{file_name}")
+
+
+@contextmanager
+def uipath_connection_mock(httpx_mock, response):
+    httpx_mock.add_response(
+        url="https://example.com/api/v1/Connections/connection-id",
+        method="GET",
+        json=response,
+    )
+
+    try:
+        yield
+    finally:
+        pass
+
+
+@contextmanager
+def uipath_token_mock(httpx_mock, response):
+    httpx_mock.add_response(
+        url="https://example.com/api/v1/Connections/connection-id/token?tokenType=direct",
+        method="GET",
+        json=response,
+    )
+
+    try:
+        yield
+    finally:
+        pass
+
+
+@contextmanager
+def uipath_integration_mock(httpx_mock, response):
+    httpx_mock.add_response(
+        url="https://example.uipath.com//v3/element/instances/0/integration",
+        method="POST",
+        json=response,
+    )
+
+    try:
+        yield
+    finally:
+        pass
+
+
+@contextmanager
+def uipath_interrupt_mock(mocker, tool_response):
+    mocker.patch(
+        "uipath_langchain.tools.preconfigured.interrupt", return_value=tool_response
+    )
+
+    try:
+        yield
+    finally:
+        pass

uipath_langchain-0.0.133/tests/tools/mocks/agent_definition.json

@@ -0,0 +1,226 @@
+{
+  "id": "agent-id",
+  "name": "agent-name",
+  "inputSchema": {
+    "type": "object",
+    "properties": {
+      "query": {
+        "type": "string"
+      }
+    }
+  },
+  "outputSchema": {
+    "type": "object",
+    "properties": {
+      "content": {
+        "type": "string",
+        "description": "Output content"
+      }
+    }
+  },
+  "version": "1.0.0",
+  "resources": [
+    {
+      "name": "Integration",
+      "description": "Integration.",
+      "$resourceType": "tool",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "query": {
+            "type": "string",
+            "description": "Query.",
+            "title": "Query"
+          }
+        },
+        "required": [
+          "query"
+        ]
+      },
+      "type": "integration",
+      "properties": {
+        "toolPath": "/integration",
+        "objectName": "v2::integration",
+        "toolDisplayName": "Integration",
+        "toolDescription": "Integration.",
+        "method": "POST",
+        "connection": {
+          "id": "connection-id",
+          "name": "integration",
+          "owner": null,
+          "createTime": null,
+          "updateTime": null,
+          "state": "enabled",
+          "apiBaseUri": "https://example.uipath.com/",
+          "elementInstanceId": 0,
+          "connector": {
+            "key": "connector-key",
+            "name": "connector-name",
+            "image": "connector-image",
+            "enabled": true
+          },
+          "isDefault": false,
+          "lastUsedTime": null,
+          "connectionIdentity": null,
+          "pollingIntervalInMinutes": null,
+          "folder": {
+            "key": "folder-key",
+            "path": "folder-path"
+          },
+          "elementVersion": null,
+          "solutionProperties": {
+            "resourceKey": "solution-resource-key"
+          }
+        },
+        "bodyStructure": {
+          "contentType": "json"
+        }
+      },
+      "location": "external",
+      "settings": {},
+      "guardrail": {
+        "policies": []
+      },
+      "iconUrl": "icon-url",
+      "id": "resource-1",
+      "isPreview": false
+    },
+    {
+      "name": "Escalation",
+      "description": "Human review.",
+      "$resourceType": "escalation",
+      "channels": [
+        {
+          "id": "escalation",
+          "name": "Channel",
+          "type": "actionCenter",
+          "description": "Channel description",
+          "inputSchema": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string",
+                "description": "Name."
+              }
+            },
+            "required": [
+              "name"
+            ]
+          },
+          "outputSchema": {
+            "type": "object",
+            "properties": {
+              "status": {
+                "type": "string",
+                "description": "Escalation status."
+              }
+            },
+            "required": [
+              "status"
+            ]
+          },
+          "properties": {
+            "appName": "ActionApp",
+            "appVersion": 1,
+            "folderName": null,
+            "resourceKey": "resource-key",
+            "isActionableMessageEnabled": false,
+            "actionableMessageMetaData": null
+          },
+          "recipients": [
+            {
+              "type": 2,
+              "value": "test-group-id",
+              "displayName": "test-group"
+            }
+          ],
+          "inputSchemaDotnetTypeMapping": {
+            "name": "System.String"
+          },
+          "outputSchemaDotnetTypeMapping": {
+            "status": "System.String"
+          },
+          "outcomeMapping": {
+            "Submit": "continue"
+          }
+        }
+      ],
+      "isAgentMemoryEnabled": false,
+      "id": "resource-2",
+      "governanceProperties": {
+        "isEscalatedAtRuntime": false
+      },
+      "escalationType": 0,
+      "vsEscalationProperties": null
+    },
+    {
+      "name": "Agent",
+      "description": "Agent.",
+      "$resourceType": "tool",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string"
+          }
+        }
+      },
+      "type": "agent",
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "content": {
+            "type": "str",
+            "description": "Output content"
+          }
+        },
+        "required": [
+          "content"
+        ]
+      },
+      "properties": {
+        "folderPath": "solution-folder",
+        "processName": "process-name"
+      },
+      "settings": {
+        "maxAttempts": null,
+        "retryDelay": null,
+        "timeout": null
+      },
+      "location": "external",
+      "guardrail": {
+        "policies": []
+      },
+      "id": "resource-3",
+      "referenceKey": "resource-3-reference-key"
+    },
+    {
+      "name": "Unknown",
+      "description": "Unknown.",
+      "$resourceType": "unknown"
+    }
+  ],
+  "type": "lowCode",
+  "messages": [
+    {
+      "role": "system",
+      "content": "System Prompt"
+    },
+    {
+      "role": "user",
+      "content": "User Prompt"
+    }
+  ],
+  "features": [],
+  "settings": {
+    "engine": "basic-v1",
+    "model": "model-1",
+    "max_tokens": 16384,
+    "temperature": 0.0
+  },
+  "metadata": {
+    "storageVersion": "22.0.0",
+    "isConversational": false
+  },
+  "guardrails": []
+}

uipath_langchain-0.0.133/tests/tools/test_preconfigured.py

@@ -0,0 +1,94 @@
+import copy
+import json
+
+from pydantic import TypeAdapter
+from uipath.agent.models.agent import AgentDefinition
+
+from tests.tools.conftest import (
+    get_file_path,
+    uipath_connection_mock,
+    uipath_integration_mock,
+    uipath_interrupt_mock,
+    uipath_token_mock,
+)
+from uipath_langchain.tools.preconfigured import safe_extract_tools
+
+
+class TestSafeExtractTools:
+    """Test class for tool extraction."""
+
+    async def test_extraction(self, monkeypatch, httpx_mock, mocker) -> None:
+        # Arrange
+        monkeypatch.setenv("UIPATH_URL", "https://example.com/")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "1234567890")
+
+        agent_definition = get_file_path("agent_definition.json")
+        with open(agent_definition) as agent_definition_file:
+            agent_definition_json = json.load(agent_definition_file)
+            agent_definition = TypeAdapter(AgentDefinition).validate_python(
+                agent_definition_json
+            )
+        tool_response = {"foo": "bar"}
+
+        # Act
+        tools = safe_extract_tools(agent_definition)
+
+        # Assert tools and schema definitions
+        assert len(tools) == 3
+        assert tools[0].input_schema.model_json_schema().get("properties") == {
+            "query": {"description": "Query.", "title": "Query", "type": "string"}
+        }
+        assert tools[0].OutputType.model_json_schema().get("properties") == {}
+        assert tools[1].input_schema.model_json_schema().get("properties") == {
+            "name": {"description": "Name.", "title": "Name", "type": "string"}
+        }
+        assert tools[1].OutputType.model_json_schema().get("properties") == {
+            "status": {
+                "description": "Escalation status.",
+                "title": "Status",
+                "type": "string",
+            }
+        }
+        assert tools[2].input_schema.model_json_schema().get("properties") == {
+            "name": {
+                "anyOf": [{"type": "string"}, {"type": "null"}],
+                "default": None,
+                "title": "Name",
+            }
+        }
+        assert tools[2].OutputType.model_json_schema().get("properties") == {
+            "content": {"description": "Output content", "title": "Content"}
+        }
+
+        # Invoke Integration
+        mock_connection = copy.deepcopy(
+            agent_definition_json["resources"][0]["properties"]["connection"]
+        )
+        mock_connection["element_instance_id"] = 1  # Updated instance id.
+
+        with (
+            uipath_connection_mock(httpx_mock, response=mock_connection),
+            uipath_token_mock(httpx_mock, response={"accessToken": "accessToken"}),
+            uipath_integration_mock(httpx_mock, tool_response),
+        ):
+            # Act
+            response = await tools[0].ainvoke(input={"query": "query"})
+
+            # Assert
+            assert response == tool_response
+
+        # Invoke Escalation
+        with uipath_interrupt_mock(mocker, tool_response):
+            # Act
+            response = await tools[1].ainvoke(input={"name": "name"})
+
+            # Assert
+            assert response == tool_response
+
+        # Invoke Escalation
+        with uipath_interrupt_mock(mocker, tool_response):
+            # Act
+            response = await tools[2].ainvoke(input={"name": "name"})
+
+            # Assert
+            assert response == tool_response