feat: propagate RunAsMe to child process tool jobs (#764)

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: dsuresh-ap

pyproject.toml

@@ -7,7 +7,7 @@ requires-python = ">=3.11"
 dependencies = [
     "uipath>=2.10.49, <2.11.0",
     "uipath-core>=0.5.2, <0.6.0",
-    "uipath-platform>=0.1.25, <0.2.0",
+    "uipath-platform>=0.1.29, <0.2.0",
     "uipath-runtime>=0.10.0, <0.11.0",
     "langgraph>=1.0.0, <2.0.0",
     "langchain-core>=1.2.11, <2.0.0",

src/uipath_langchain/agent/tools/process_tool.py

@@ -39,7 +39,10 @@
 }
 
 
-def create_process_tool(resource: AgentProcessToolResourceConfig) -> StructuredTool:
+def create_process_tool(
+    resource: AgentProcessToolResourceConfig,
+    run_as_me: bool = False,
+) -> StructuredTool:
     """Uses interrupt() to suspend graph execution until process completes (handled by runtime)."""
     # Import here to avoid circular dependency
     from uipath_langchain.agent.wrappers import get_job_attachment_wrapper
@@ -80,6 +83,7 @@ async def start_job():
                         attachments=attachments,
                         parent_span_id=parent_span_id,
                         parent_operation_id=parent_operation_id,
+                        run_as_me=True if run_as_me else None,
                     )
                 except EnrichedException as e:
                     raise_for_enriched(

src/uipath_langchain/agent/tools/tool_factory.py

@@ -29,11 +29,32 @@
 logger = getLogger(__name__)
 
 
+def _is_user_token() -> bool:
+    """Check if the current token is a user token (sub_type == 'user')."""
+    try:
+        from uipath._cli._utils._common import get_claim_from_token
+
+        sub_type = get_claim_from_token("sub_type")
+        logger.info("Token sub_type=%r", sub_type)
+        return sub_type == "user"
+    except Exception as e:
+        logger.info("Token sub_type check failed: %s", e)
+        return False
+
+
 async def create_tools_from_resources(
     agent: LowCodeAgentDefinition, llm: BaseChatModel
 ) -> list[BaseTool]:
 
     tools: list[BaseTool] = []
+    is_user = _is_user_token()
+    run_as_me = agent.is_conversational and is_user
+    logger.info(
+        "RunAsMe decision: is_conversational=%s, is_user_token=%s, run_as_me=%s",
+        agent.is_conversational,
+        is_user,
+        run_as_me,
+    )
 
     logger.info("Creating tools for agent '%s' from resources", agent.name)
 
@@ -51,7 +72,9 @@ async def create_tools_from_resources(
             resource.name,
             type(resource).__name__,
         )
-        tool = await _build_tool_for_resource(resource, llm, agent=agent)
+        tool = await _build_tool_for_resource(
+            resource, llm, agent=agent, run_as_me=run_as_me
+        )
         if tool is not None:
             if isinstance(tool, list):
                 tools.extend(tool)
@@ -74,9 +97,10 @@ async def _build_tool_for_resource(
     resource: BaseAgentResourceConfig,
     llm: BaseChatModel,
     agent: LowCodeAgentDefinition | None = None,
+    run_as_me: bool = False,
 ) -> BaseTool | list[BaseTool] | None:
     if isinstance(resource, AgentProcessToolResourceConfig):
-        return create_process_tool(resource)
+        return create_process_tool(resource, run_as_me=run_as_me)
 
     elif isinstance(resource, AgentContextResourceConfig):
         return create_context_tool(resource, llm=llm, agent=agent)

tests/agent/tools/test_process_tool.py

@@ -147,6 +147,7 @@ async def test_invoke_calls_processes_invoke_async(
             attachments=[],
             parent_span_id=None,
             parent_operation_id=None,
+            run_as_me=None,
         )
 
     @pytest.mark.asyncio
@@ -358,3 +359,97 @@ async def test_span_context_defaults_to_none_when_empty(
 
         call_kwargs = mock_client.processes.invoke_async.call_args[1]
         assert call_kwargs["parent_span_id"] is None
+
+
+class TestProcessToolRunAsMe:
+    """Test RunAsMe propagation passed top-down from tool factory."""
+
+    @pytest.mark.asyncio
+    @patch("uipath_langchain._utils.durable_interrupt.decorator.interrupt")
+    @patch("uipath_langchain.agent.tools.process_tool.UiPath")
+    async def test_run_as_me_true_passed_to_invoke(
+        self,
+        mock_uipath_class,
+        mock_interrupt,
+        process_resource,
+    ):
+        """Test RunAsMe=True is forwarded to invoke_async when set."""
+        mock_job = MagicMock(spec=Job)
+        mock_job.key = "job-key"
+        mock_job.folder_key = "folder-key"
+
+        mock_resumed_job = MagicMock(spec=Job)
+        mock_resumed_job.state = "successful"
+
+        mock_client = MagicMock()
+        mock_client.processes.invoke_async = AsyncMock(return_value=mock_job)
+        mock_client.jobs.extract_output_async = AsyncMock(return_value=None)
+        mock_uipath_class.return_value = mock_client
+
+        mock_interrupt.return_value = mock_resumed_job
+
+        tool = create_process_tool(process_resource, run_as_me=True)
+        await tool.ainvoke({})
+
+        call_kwargs = mock_client.processes.invoke_async.call_args[1]
+        assert call_kwargs["run_as_me"] is True
+
+    @pytest.mark.asyncio
+    @patch("uipath_langchain._utils.durable_interrupt.decorator.interrupt")
+    @patch("uipath_langchain.agent.tools.process_tool.UiPath")
+    async def test_run_as_me_false_sends_none(
+        self,
+        mock_uipath_class,
+        mock_interrupt,
+        process_resource,
+    ):
+        """Test RunAsMe=None when run_as_me=False (default)."""
+        mock_job = MagicMock(spec=Job)
+        mock_job.key = "job-key"
+        mock_job.folder_key = "folder-key"
+
+        mock_resumed_job = MagicMock(spec=Job)
+        mock_resumed_job.state = "successful"
+
+        mock_client = MagicMock()
+        mock_client.processes.invoke_async = AsyncMock(return_value=mock_job)
+        mock_client.jobs.extract_output_async = AsyncMock(return_value=None)
+        mock_uipath_class.return_value = mock_client
+
+        mock_interrupt.return_value = mock_resumed_job
+
+        tool = create_process_tool(process_resource, run_as_me=False)
+        await tool.ainvoke({})
+
+        call_kwargs = mock_client.processes.invoke_async.call_args[1]
+        assert call_kwargs["run_as_me"] is None
+
+    @pytest.mark.asyncio
+    @patch("uipath_langchain._utils.durable_interrupt.decorator.interrupt")
+    @patch("uipath_langchain.agent.tools.process_tool.UiPath")
+    async def test_run_as_me_default_sends_none(
+        self,
+        mock_uipath_class,
+        mock_interrupt,
+        process_resource,
+    ):
+        """Test RunAsMe=None when run_as_me not specified (default)."""
+        mock_job = MagicMock(spec=Job)
+        mock_job.key = "job-key"
+        mock_job.folder_key = "folder-key"
+
+        mock_resumed_job = MagicMock(spec=Job)
+        mock_resumed_job.state = "successful"
+
+        mock_client = MagicMock()
+        mock_client.processes.invoke_async = AsyncMock(return_value=mock_job)
+        mock_client.jobs.extract_output_async = AsyncMock(return_value=None)
+        mock_uipath_class.return_value = mock_client
+
+        mock_interrupt.return_value = mock_resumed_job
+
+        tool = create_process_tool(process_resource)
+        await tool.ainvoke({})
+
+        call_kwargs = mock_client.processes.invoke_async.call_args[1]
+        assert call_kwargs["run_as_me"] is None