feat: use execution folder instead of dummy folder paths (#653)

Author: andreiancuta-uipath

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath-langchain"
-version = "0.7.16"
+version = "0.7.17"
 description = "Python SDK that enables developers to build and deploy LangGraph agents to the UiPath Cloud Platform"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

src/uipath_langchain/_utils/__init__.py

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

src/uipath_langchain/_utils/_environment.py

@@ -0,0 +1,6 @@
+import os
+
+
+def get_execution_folder_path() -> str | None:
+    """Reads the agent's executing folder path from the runtime environment."""
+    return os.environ.get("UIPATH_FOLDER_PATH")

src/uipath_langchain/agent/tools/context_tool.py

@@ -21,6 +21,7 @@
 )
 from uipath.runtime.errors import UiPathErrorCategory
 
+from uipath_langchain._utils import get_execution_folder_path
 from uipath_langchain.agent.exceptions import AgentStartupError, AgentStartupErrorCode
 from uipath_langchain.agent.react.jsonschema_pydantic_converter import (
     create_model as create_model_from_schema,
@@ -68,7 +69,7 @@ def handle_semantic_search(
 
     retriever = ContextGroundingRetriever(
         index_name=resource.index_name,
-        folder_path=resource.folder_path,
+        folder_path=get_execution_folder_path(),
         number_of_results=resource.settings.result_count,
     )
 
@@ -204,7 +205,7 @@ async def create_deep_rag():
                 index_name=index_name,
                 prompt=actual_prompt,
                 citation_mode=citation_mode,
-                index_folder_path=resource.folder_path,
+                index_folder_path=get_execution_folder_path(),
                 glob_pattern=glob_pattern,
             )
 
@@ -234,7 +235,7 @@ def handle_batch_transform(
     assert resource.settings.query.variant is not None
 
     index_name = resource.index_name
-    index_folder_path = resource.folder_path
+    index_folder_path = get_execution_folder_path()
     if not resource.settings.web_search_grounding:
         raise AgentStartupError(
             code=AgentStartupErrorCode.INVALID_TOOL_CONFIG,

src/uipath_langchain/agent/tools/escalation_tool.py

@@ -20,6 +20,7 @@
 from uipath.platform.common import WaitEscalation
 from uipath.runtime.errors import UiPathErrorCategory
 
+from uipath_langchain._utils import get_execution_folder_path
 from uipath_langchain.agent.react.jsonschema_pydantic_converter import create_model
 from uipath_langchain.agent.tools.static_args import (
     handle_static_args,
@@ -51,7 +52,7 @@ async def resolve_recipient_value(
 ) -> TaskRecipient | None:
     """Resolve recipient value based on recipient type."""
     if isinstance(recipient, AssetRecipient):
-        value = await resolve_asset(recipient.asset_name, recipient.folder_path)
+        value = await resolve_asset(recipient.asset_name, get_execution_folder_path())
         type = None
         if recipient.type == AgentEscalationRecipientType.ASSET_USER_EMAIL:
             type = TaskRecipientType.EMAIL
@@ -70,7 +71,7 @@ async def resolve_recipient_value(
     return None
 
 
-async def resolve_asset(asset_name: str, folder_path: str) -> str | None:
+async def resolve_asset(asset_name: str, folder_path: str | None) -> str | None:
     """Retrieve asset value."""
     try:
         client = UiPath()
@@ -162,6 +163,7 @@ async def escalation_tool_fn(**kwargs: Any) -> dict[str, Any]:
             if channel.recipients
             else None
         )
+        folder_path = get_execution_folder_path()
 
         task_title = "Escalation Task"
         if tool.metadata is not None:
@@ -186,7 +188,7 @@ async def create_escalation_task():
                     title=task_title,
                     data=serialized_data,
                     app_name=channel.properties.app_name,
-                    app_folder_path=channel.properties.folder_name or "",
+                    app_folder_path=folder_path,
                     recipient=recipient,
                     priority=channel.priority,
                     labels=channel.labels,
@@ -199,7 +201,7 @@ async def create_escalation_task():
 
                 return WaitEscalation(
                     action=created_task,
-                    app_folder_path=channel.properties.folder_name,
+                    app_folder_path=folder_path,
                     app_name=channel.properties.app_name,
                     recipient=recipient,
                 )

src/uipath_langchain/agent/tools/mcp/mcp_client.py

@@ -19,6 +19,8 @@
 from uipath._utils._ssl_context import get_httpx_client_kwargs
 from uipath.runtime.base import UiPathDisposableProtocol
 
+from uipath_langchain._utils import get_execution_folder_path
+
 from .streamable_http import SessionInfo, streamable_http_client
 
 if TYPE_CHECKING:
@@ -137,9 +139,10 @@ async def _initialize_client(self) -> None:
 
         Then calls _initialize_session() to complete the MCP handshake.
         """
+        folder_path = get_execution_folder_path()
         logger.debug(
             f"Initializing MCP client for '{self._config.slug}' "
-            f"in folder '{self._config.folder_path}'"
+            f"in folder '{folder_path}'"
         )
 
         # Lazy import to improve cold start time
@@ -148,7 +151,7 @@ async def _initialize_client(self) -> None:
         # Retrieve MCP server URL from SDK
         sdk = UiPath()
         mcp_server = await sdk.mcp.retrieve_async(
-            slug=self._config.slug, folder_path=self._config.folder_path
+            slug=self._config.slug, folder_path=folder_path
         )
 
         if mcp_server.mcp_url is None:

src/uipath_langchain/agent/tools/process_tool.py

@@ -12,6 +12,7 @@
 from uipath.platform.common import WaitJobRaw
 from uipath.platform.orchestrator import JobState
 
+from uipath_langchain._utils import get_execution_folder_path
 from uipath_langchain.agent.react.job_attachments import get_job_attachments
 from uipath_langchain.agent.react.jsonschema_pydantic_converter import create_model
 from uipath_langchain.agent.react.types import AgentGraphState
@@ -34,7 +35,7 @@ def create_process_tool(resource: AgentProcessToolResourceConfig) -> StructuredT
 
     tool_name: str = sanitize_tool_name(resource.name)
     process_name = resource.properties.process_name
-    folder_path = resource.properties.folder_path
+    folder_path = get_execution_folder_path()
 
     input_model: Any = create_model(resource.input_schema)
     output_model: Any = create_model(resource.output_schema)

tests/agent/tools/test_context_tool.py

@@ -1,6 +1,7 @@
 """Tests for context_tool.py module."""
 
-from unittest.mock import AsyncMock, patch
+import os
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 from langchain_core.documents import Document
@@ -271,6 +272,27 @@ async def test_dynamic_query_uses_provided_query(self, base_resource_config):
             call_args = mock_interrupt.call_args[0][0]
             assert call_args.prompt == "runtime provided query"
 
+    @pytest.mark.asyncio
+    @patch.dict(os.environ, {"UIPATH_FOLDER_PATH": "/Shared/TestFolder"})
+    async def test_deep_rag_uses_execution_folder_path(self, base_resource_config):
+        """Test that CreateDeepRag receives index_folder_path from the execution environment."""
+        resource = base_resource_config(
+            query_variant="static",
+            query_value="test query",
+            citation_mode_value=AgentContextValueSetting(value="Inline"),
+        )
+        tool = handle_deep_rag("test_tool", resource)
+
+        with patch(
+            "uipath_langchain.agent.tools.durable_interrupt.decorator.interrupt"
+        ) as mock_interrupt:
+            mock_interrupt.return_value = {"mocked": "response"}
+            assert tool.coroutine is not None
+            await tool.coroutine()
+
+            deep_rag_arg = mock_interrupt.call_args[0][0]
+            assert deep_rag_arg.index_folder_path == "/Shared/TestFolder"
+
 
 class TestCreateContextTool:
     """Test cases for create_context_tool function."""
@@ -490,6 +512,17 @@ async def test_static_query_uses_predefined_query(self):
             assert "documents" in result
             assert len(result["documents"]) == 1
 
+    @patch.dict(os.environ, {"UIPATH_FOLDER_PATH": "/Shared/TestFolder"})
+    def test_semantic_search_uses_execution_folder_path(self, semantic_config):
+        """Test that ContextGroundingRetriever receives folder_path from the execution environment."""
+        with patch(
+            "uipath_langchain.agent.tools.context_tool.ContextGroundingRetriever"
+        ) as mock_retriever_class:
+            handle_semantic_search("semantic_tool", semantic_config)
+
+            call_kwargs = mock_retriever_class.call_args[1]
+            assert call_kwargs["folder_path"] == "/Shared/TestFolder"
+
 
 class TestHandleBatchTransform:
     """Test cases for handle_batch_transform function."""
@@ -771,6 +804,32 @@ async def test_dynamic_query_batch_transform_uses_default_destination_path(self)
             assert call_args.prompt == "runtime provided query"
             assert call_args.destination_path == "output.csv"
 
+    @pytest.mark.asyncio
+    @patch.dict(os.environ, {"UIPATH_FOLDER_PATH": "/Shared/TestFolder"})
+    async def test_batch_transform_uses_execution_folder_path(
+        self, batch_transform_config
+    ):
+        """Test that CreateBatchTransform receives index_folder_path from the execution environment."""
+        tool = handle_batch_transform("batch_transform_tool", batch_transform_config)
+
+        mock_uipath = MagicMock()
+        mock_uipath.jobs.create_attachment_async = AsyncMock(return_value="att-id")
+        with (
+            patch(
+                "uipath_langchain.agent.tools.durable_interrupt.decorator.interrupt"
+            ) as mock_interrupt,
+            patch(
+                "uipath_langchain.agent.tools.context_tool.UiPath",
+                return_value=mock_uipath,
+            ),
+        ):
+            mock_interrupt.return_value = MagicMock()
+            assert tool.coroutine is not None
+            await tool.coroutine(destination_path="output.csv")
+
+            batch_transform_arg = mock_interrupt.call_args[0][0]
+            assert batch_transform_arg.index_folder_path == "/Shared/TestFolder"
+
 
 class TestBuildGlobPattern:
     """Test cases for build_glob_pattern function."""

tests/agent/tools/test_escalation_tool.py

@@ -1,5 +1,6 @@
 """Tests for escalation_tool.py metadata."""
 
+import os
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
@@ -111,6 +112,7 @@ class TestResolveRecipientValue:
     """Test the resolve_recipient_value function."""
 
     @pytest.mark.asyncio
+    @patch.dict(os.environ, {"UIPATH_FOLDER_PATH": "/Test/Folder"})
     @patch("uipath_langchain.agent.tools.escalation_tool.resolve_asset")
     async def test_resolve_recipient_asset_user_email(self, mock_resolve_asset):
         """Test ASSET_USER_EMAIL type calls resolve_asset."""
@@ -132,6 +134,7 @@ async def test_resolve_recipient_asset_user_email(self, mock_resolve_asset):
         mock_resolve_asset.assert_called_once_with("email_asset", "/Test/Folder")
 
     @pytest.mark.asyncio
+    @patch.dict(os.environ, {"UIPATH_FOLDER_PATH": "/Test/Folder"})
     @patch("uipath_langchain.agent.tools.escalation_tool.resolve_asset")
     async def test_resolve_recipient_asset_group_name(self, mock_resolve_asset):
         """Test ASSET_GROUP_NAME type calls resolve_asset."""
@@ -834,6 +837,34 @@ async def test_creates_task_then_interrupts_with_wait_escalation(
         assert isinstance(interrupt_arg, WaitEscalation)
         assert interrupt_arg.action == task
 
+    @pytest.mark.asyncio
+    @patch.dict(os.environ, {"UIPATH_FOLDER_PATH": "/Test/Folder"})
+    @patch("uipath_langchain.agent.tools.escalation_tool.UiPath")
+    @patch("uipath_langchain.agent.tools.durable_interrupt.decorator.interrupt")
+    async def test_creates_task_with_execution_folder_path(
+        self, mock_interrupt, mock_uipath_class, escalation_resource
+    ):
+        """Test that tasks.create_async receives app_folder_path from the execution environment."""
+        task = _make_mock_task(id=555)
+        mock_client = MagicMock()
+        mock_client.tasks.create_async = AsyncMock(return_value=task)
+        mock_uipath_class.return_value = mock_client
+
+        mock_result = MagicMock()
+        mock_result.id = 555
+        mock_result.action = "approve"
+        mock_result.data = {}
+        mock_result.assigned_to_user = None
+        mock_result.is_deleted = False
+        mock_interrupt.return_value = mock_result
+
+        tool = create_escalation_tool(escalation_resource)
+        call = ToolCall(args={}, id="test-call", name=tool.name)
+        await tool.awrapper(tool, call, {})  # type: ignore[attr-defined]
+
+        create_call_kwargs = mock_client.tasks.create_async.call_args[1]
+        assert create_call_kwargs["app_folder_path"] == "/Test/Folder"
+
     @pytest.mark.asyncio
     @patch("uipath_langchain.agent.tools.escalation_tool.UiPath")
     async def test_task_creation_failure_propagates(

tests/agent/tools/test_mcp/test_mcp_client.py

@@ -2,6 +2,7 @@
 
 import json
 import logging
+import os
 from typing import Any
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -780,3 +781,38 @@ async def test_list_tools_reuses_session(
         assert list_tools_count == 2
 
         await client.dispose()
+
+    @pytest.mark.asyncio
+    @patch.dict(os.environ, {"UIPATH_FOLDER_PATH": "/Shared/TestFolder"})
+    @patch("httpx.AsyncClient")
+    async def test_retrieve_async_uses_execution_folder_path(
+        self, mock_async_client_class, mcp_resource_config
+    ):
+        """Test that retrieve_async is called with folder_path from the execution environment."""
+        mock_sdk = MagicMock()
+        mock_server = MagicMock()
+        mock_server.mcp_url = "https://test.uipath.com/mcp"
+        mock_sdk.mcp.retrieve_async = AsyncMock(return_value=mock_server)
+        mock_sdk._config = MagicMock()
+        mock_sdk._config.secret = "test-secret-token"
+
+        method_call_sequence: list[str] = []
+        initialize_count = [0]
+        tool_call_count = [0]
+
+        MockStreamResponse = self.create_mock_stream_response(
+            method_call_sequence, initialize_count, tool_call_count
+        )
+        mock_http_client = self.create_mock_http_client(MockStreamResponse)
+        mock_async_client_class.return_value = mock_http_client
+
+        session = McpClient(config=mcp_resource_config)
+
+        with patch("uipath.platform.UiPath", return_value=mock_sdk):
+            await session.call_tool("test_tool", {"query": "test"})
+
+        mock_sdk.mcp.retrieve_async.assert_called_once_with(
+            slug="test-server", folder_path="/Shared/TestFolder"
+        )
+
+        await session.dispose()