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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.132
+Version: 0.0.134
 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.64
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.132 → uipath_langchain-0.0.134}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "uipath-langchain"
-version = "0.0.132"
+version = "0.0.134"
 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.64, <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.134}/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.132 → uipath_langchain-0.0.134}/src/uipath_langchain/_cli/cli_eval.py

@@ -1,16 +1,19 @@
 import asyncio
+import uuid
 from typing import List, Optional
 
 from openinference.instrumentation.langchain import (
     LangChainInstrumentor,
     get_current_span,
 )
+from uipath._cli._evals._progress_reporter import StudioWebProgressReporter
 from uipath._cli._evals._runtime import UiPathEvalContext, UiPathEvalRuntime
 from uipath._cli._runtime._contracts import (
     UiPathRuntimeFactory,
 )
 from uipath._cli._utils._eval_set import EvalHelpers
 from uipath._cli.middlewares import MiddlewareResult
+from uipath._events._event_bus import EventBus
 from uipath.eval._helpers import auto_discover_entrypoint
 
 from uipath_langchain._cli._runtime._context import LangGraphRuntimeContext
@@ -31,14 +34,16 @@ def langgraph_eval_middleware(
             should_continue=True
         )  # Continue with normal flow if no langgraph.json
 
-    eval_context = UiPathEvalContext.with_defaults(**kwargs)
-    eval_context.eval_set = eval_set or EvalHelpers.auto_discover_eval_set()
-    eval_context.eval_ids = eval_ids
-
     try:
         _instrument_traceable_attributes()
 
-        runtime_entrypoint = entrypoint or auto_discover_entrypoint()
+        event_bus = EventBus()
+
+        if not kwargs.get("no_report", False):
+            progress_reporter = StudioWebProgressReporter(
+                spans_exporter=LangChainExporter()
+            )
+            asyncio.run(progress_reporter.subscribe_to_eval_runtime_events(event_bus))
 
         def generate_runtime_context(
             context_entrypoint: str, langgraph_config: LangGraphConfig, **context_kwargs
@@ -48,6 +53,14 @@ def langgraph_eval_middleware(
             context.entrypoint = context_entrypoint
             return context
 
+        runtime_entrypoint = entrypoint or auto_discover_entrypoint()
+
+        eval_context = UiPathEvalContext.with_defaults(
+            entrypoint=runtime_entrypoint, execution_id=str(uuid.uuid4()), **kwargs
+        )
+        eval_context.eval_set = eval_set or EvalHelpers.auto_discover_eval_set()
+        eval_context.eval_ids = eval_ids
+
         runtime_factory = UiPathRuntimeFactory(
             LangGraphRuntime,
             LangGraphRuntimeContext,
@@ -65,9 +78,10 @@ def langgraph_eval_middleware(
 
         async def execute():
             async with UiPathEvalRuntime.from_eval_context(
-                factory=runtime_factory, context=eval_context
+                factory=runtime_factory, context=eval_context, event_bus=event_bus
             ) as eval_runtime:
                 await eval_runtime.execute()
+                await event_bus.wait_for_all()
 
         asyncio.run(execute())
         return MiddlewareResult(should_continue=False)

uipath_langchain-0.0.134/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.134/tests/tools/__init__.py

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

uipath_langchain-0.0.134/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.134/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": []
+}