uipath-langchain 0.1.28__py3-none-any.whl → 0.3.1__py3-none-any.whl

uipath_langchain/agent/tools/escalation_tool.py

@@ -3,10 +3,9 @@
 from enum import Enum
 from typing import Any
 
-from jsonschema_pydantic_converter import transform as create_model
-from langchain.tools import ToolRuntime
 from langchain_core.messages import ToolMessage
-from langchain_core.tools import StructuredTool
+from langchain_core.messages.tool import ToolCall
+from langchain_core.tools import BaseTool, StructuredTool
 from langgraph.types import Command, interrupt
 from uipath.agent.models.agent import (
     AgentEscalationChannel,
@@ -16,7 +15,10 @@ from uipath.agent.models.agent import (
 from uipath.eval.mocks import mockable
 from uipath.platform.common import CreateEscalation
 
-from ..react.types import AgentGraphNode, AgentTerminationSource
+from uipath_langchain.agent.react.jsonschema_pydantic_converter import create_model
+
+from ..react.types import AgentGraphNode, AgentGraphState, AgentTerminationSource
+from .tool_node import ToolWrapperMixin
 from .utils import sanitize_tool_name
 
 
@@ -27,7 +29,11 @@ class EscalationAction(str, Enum):
     END = "end"
 
 
-def create_escalation_tool(resource: AgentEscalationResourceConfig) -> StructuredTool:
+class StructuredToolWithWrapper(StructuredTool, ToolWrapperMixin):
+    pass
+
+
+def create_escalation_tool(resource: AgentEscalationResourceConfig) -> BaseTool:
     """Uses interrupt() for Action Center human-in-the-loop."""
 
     tool_name: str = f"escalate_{sanitize_tool_name(resource.name)}"
@@ -48,10 +54,9 @@ def create_escalation_tool(resource: AgentEscalationResourceConfig) -> Structure
         description=resource.description,
         input_schema=input_model.model_json_schema(),
         output_schema=output_model.model_json_schema(),
+        example_calls=channel.properties.example_calls,
     )
-    async def escalation_tool_fn(
-        runtime: ToolRuntime, **kwargs: Any
-    ) -> Command[Any] | Any:
+    async def escalation_tool_fn(**kwargs: Any) -> dict[str, Any]:
         task_title = channel.task_title or "Escalation Task"
 
         result = interrupt(
@@ -72,22 +77,41 @@ def create_escalation_tool(resource: AgentEscalationResourceConfig) -> Structure
         escalation_action = getattr(result, "action", None)
         escalation_output = getattr(result, "data", {})
 
-        outcome = (
+        outcome_str = (
             channel.outcome_mapping.get(escalation_action)
             if channel.outcome_mapping and escalation_action
             else None
         )
+        outcome = (
+            EscalationAction(outcome_str) if outcome_str else EscalationAction.CONTINUE
+        )
 
-        if outcome == EscalationAction.END:
-            output_detail = f"Escalation output: {escalation_output}"
-            termination_title = f"Agent run ended based on escalation outcome {outcome} with directive {escalation_action}"
+        return {
+            "action": outcome,
+            "output": escalation_output,
+            "escalation_action": escalation_action,
+        }
+
+    async def escalation_wrapper(
+        tool: BaseTool,
+        call: ToolCall,
+        state: AgentGraphState,
+    ) -> dict[str, Any] | Command[Any]:
+        result = await tool.ainvoke(call["args"])
+
+        if result["action"] == EscalationAction.END:
+            output_detail = f"Escalation output: {result['output']}"
+            termination_title = (
+                f"Agent run ended based on escalation outcome {result['action']} "
+                f"with directive {result['escalation_action']}"
+            )
 
             return Command(
                 update={
                     "messages": [
                         ToolMessage(
                             content=f"{termination_title}. {output_detail}",
-                            tool_call_id=runtime.tool_call_id,
+                            tool_call_id=call["id"],
                         )
                     ],
                     "termination": {
@@ -99,13 +123,20 @@ def create_escalation_tool(resource: AgentEscalationResourceConfig) -> Structure
                 goto=AgentGraphNode.TERMINATE,
             )
 
-        return escalation_output
+        return result["output"]
 
-    tool = StructuredTool(
+    tool = StructuredToolWithWrapper(
         name=tool_name,
         description=resource.description,
         args_schema=input_model,
         coroutine=escalation_tool_fn,
+        metadata={
+            "tool_type": "escalation",
+            "display_name": channel.properties.app_name,
+            "channel_type": channel.type,
+            "assignee": assignee,
+        },
     )
+    tool.set_tool_wrappers(awrapper=escalation_wrapper)
 
     return tool

uipath_langchain/agent/tools/integration_tool.py

@@ -3,17 +3,21 @@
 import copy
 from typing import Any
 
-from jsonschema_pydantic_converter import transform as create_model
-from langchain.tools import ToolRuntime
 from langchain_core.tools import StructuredTool
 from uipath.agent.models.agent import AgentIntegrationToolResourceConfig
 from uipath.eval.mocks import mockable
 from uipath.platform import UiPath
 from uipath.platform.connections import ActivityMetadata, ActivityParameterLocationInfo
 
-from .static_args import handle_static_args
+from uipath_langchain.agent.react.jsonschema_pydantic_converter import create_model
+from uipath_langchain.agent.tools.tool_node import ToolWrapperMixin
+
 from .structured_tool_with_output_type import StructuredToolWithOutputType
-from .utils import sanitize_tool_name
+from .utils import sanitize_dict_for_serialization, sanitize_tool_name
+
+
+class StructuredToolWithStaticArgs(StructuredToolWithOutputType, ToolWrapperMixin):
+    pass
 
 
 def remove_asterisk_from_properties(fields: dict[str, Any]) -> dict[str, Any]:
@@ -149,33 +153,33 @@ def create_integration_tool(
         description=resource.description,
         input_schema=input_model.model_json_schema(),
         output_schema=output_model.model_json_schema(),
+        example_calls=resource.properties.example_calls,
     )
-    async def integration_tool_fn(runtime: ToolRuntime, **kwargs: Any):
+    async def integration_tool_fn(**kwargs: Any):
         try:
-            # we manually validating here and not passing input_model to StructuredTool
-            # because langchain itself will block their own injected arguments (like runtime) if the model is strict
-            val_args = input_model.model_validate(kwargs)
-            args = handle_static_args(
-                resource=resource,
-                runtime=runtime,
-                input_args=val_args.model_dump(),
-            )
             result = await sdk.connections.invoke_activity_async(
                 activity_metadata=activity_metadata,
                 connection_id=connection_id,
-                activity_input=args,
+                activity_input=sanitize_dict_for_serialization(kwargs),
             )
         except Exception:
             raise
 
         return result
 
-    tool = StructuredToolWithOutputType(
+    from uipath_langchain.agent.wrappers.static_args_wrapper import (
+        get_static_args_wrapper,
+    )
+
+    wrapper = get_static_args_wrapper(resource)
+
+    tool = StructuredToolWithStaticArgs(
         name=tool_name,
         description=resource.description,
-        args_schema=resource.input_schema,
+        args_schema=input_model,
         coroutine=integration_tool_fn,
         output_type=output_model,
     )
+    tool.set_tool_wrappers(awrapper=wrapper)
 
     return tool

uipath_langchain/agent/tools/internal_tools/__init__.py

@@ -0,0 +1,5 @@
+"""Internal Tool creation and management for LowCode agents."""
+
+from .internal_tool_factory import create_internal_tool
+
+__all__ = ["create_internal_tool"]

uipath_langchain/agent/tools/internal_tools/analyze_files_tool.py

@@ -0,0 +1,113 @@
+import uuid
+from typing import Any
+
+from langchain_core.language_models import BaseChatModel
+from langchain_core.messages import AnyMessage, HumanMessage, SystemMessage
+from langchain_core.tools import StructuredTool
+from uipath.agent.models.agent import (
+    AgentInternalToolResourceConfig,
+)
+from uipath.eval.mocks import mockable
+from uipath.platform import UiPath
+
+from uipath_langchain.agent.react.jsonschema_pydantic_converter import create_model
+from uipath_langchain.agent.react.llm_with_files import FileInfo, llm_call_with_files
+from uipath_langchain.agent.tools.structured_tool_with_output_type import (
+    StructuredToolWithOutputType,
+)
+from uipath_langchain.agent.tools.tool_node import ToolWrapperMixin
+from uipath_langchain.agent.tools.utils import sanitize_tool_name
+
+ANALYZE_FILES_SYSTEM_MESSAGE = (
+    "Process the provided files to complete the given task. "
+    "Analyze the files contents thoroughly to deliver an accurate response "
+    "based on the extracted information."
+)
+
+
+class AnalyzeFileTool(StructuredToolWithOutputType, ToolWrapperMixin):
+    pass
+
+
+def create_analyze_file_tool(
+    resource: AgentInternalToolResourceConfig, llm: BaseChatModel
+) -> StructuredTool:
+    from uipath_langchain.agent.wrappers.job_attachment_wrapper import (
+        get_job_attachment_wrapper,
+    )
+
+    tool_name = sanitize_tool_name(resource.name)
+    input_model = create_model(resource.input_schema)
+    output_model = create_model(resource.output_schema)
+
+    @mockable(
+        name=resource.name,
+        description=resource.description,
+        input_schema=input_model.model_json_schema(),
+        output_schema=output_model.model_json_schema(),
+    )
+    async def tool_fn(**kwargs: Any):
+        if "analysisTask" not in kwargs:
+            raise ValueError("Argument 'analysisTask' is not available")
+        if "attachments" not in kwargs:
+            raise ValueError("Argument 'attachments' is not available")
+
+        attachments = kwargs["attachments"]
+        analysisTask = kwargs["analysisTask"]
+
+        files = await _resolve_job_attachment_arguments(attachments)
+        messages: list[AnyMessage] = [
+            SystemMessage(content=ANALYZE_FILES_SYSTEM_MESSAGE),
+            HumanMessage(content=analysisTask),
+        ]
+        result = await llm_call_with_files(messages, files, llm)
+        return result
+
+    wrapper = get_job_attachment_wrapper()
+    tool = AnalyzeFileTool(
+        name=tool_name,
+        description=resource.description,
+        args_schema=input_model,
+        coroutine=tool_fn,
+        output_type=output_model,
+    )
+    tool.set_tool_wrappers(awrapper=wrapper)
+    return tool
+
+
+async def _resolve_job_attachment_arguments(
+    attachments: list[Any],
+) -> list[FileInfo]:
+    """Resolve job attachments to FileInfo objects.
+
+    Args:
+        attachments: List of job attachment objects (dynamically typed from schema)
+
+    Returns:
+        List of FileInfo objects with blob URIs for each attachment
+    """
+    client = UiPath()
+    file_infos: list[FileInfo] = []
+
+    for attachment in attachments:
+        # Access using Pydantic field aliases (ID, FullName, MimeType)
+        # These are dynamically created from the JSON schema
+        attachment_id_value = getattr(attachment, "ID", None)
+        if attachment_id_value is None:
+            continue
+
+        attachment_id = uuid.UUID(attachment_id_value)
+        mime_type = getattr(attachment, "MimeType", "")
+
+        blob_info = await client.attachments.get_blob_file_access_uri_async(
+            key=attachment_id
+        )
+
+        file_info = FileInfo(
+            url=blob_info.uri,
+            name=blob_info.name,
+            mime_type=mime_type,
+        )
+        file_infos.append(file_info)
+
+    return file_infos

uipath_langchain/agent/tools/internal_tools/internal_tool_factory.py

@@ -0,0 +1,54 @@
+"""Factory for creating internal agent tools.
+
+This module provides a factory pattern for creating internal tools used by agents.
+Internal tools are built-in tools that provide core functionality for agents, such as
+file analysis, data processing, or other utilities that don't require external integrations.
+
+Supported Internal Tools:
+    - ANALYZE_FILES: Tool for analyzing file contents and extracting information
+
+Example:
+    >>> from uipath.agent.models.agent import AgentInternalToolResourceConfig
+    >>> resource = AgentInternalToolResourceConfig(...)
+    >>> tool = create_internal_tool(resource)
+    >>> # Use the tool in your agent workflow
+"""
+
+from typing import Callable
+
+from langchain_core.language_models import BaseChatModel
+from langchain_core.tools import StructuredTool
+from uipath.agent.models.agent import (
+    AgentInternalToolResourceConfig,
+    AgentInternalToolType,
+)
+
+from .analyze_files_tool import create_analyze_file_tool
+
+_INTERNAL_TOOL_HANDLERS: dict[
+    AgentInternalToolType,
+    Callable[[AgentInternalToolResourceConfig, BaseChatModel], StructuredTool],
+] = {
+    AgentInternalToolType.ANALYZE_FILES: create_analyze_file_tool,
+}
+
+
+def create_internal_tool(
+    resource: AgentInternalToolResourceConfig, llm: BaseChatModel
+) -> StructuredTool:
+    """Create an internal tool based on the resource configuration.
+
+    Raises:
+        ValueError: If the tool type is not supported (no handler exists for it).
+
+    """
+    tool_type = resource.properties.tool_type
+
+    handler = _INTERNAL_TOOL_HANDLERS.get(tool_type)
+    if handler is None:
+        raise ValueError(
+            f"Unsupported internal tool type: {tool_type}. "
+            f"Supported types: {list[AgentInternalToolType](_INTERNAL_TOOL_HANDLERS.keys())}"
+        )
+
+    return handler(resource, llm)

uipath_langchain/agent/tools/mcp_tool.py

@@ -0,0 +1,86 @@
+import asyncio
+import os
+from collections import Counter, defaultdict
+from contextlib import AsyncExitStack, asynccontextmanager
+from itertools import chain
+
+import httpx
+from langchain_core.tools import BaseTool
+from langchain_mcp_adapters.tools import load_mcp_tools
+from mcp import ClientSession
+from mcp.client.streamable_http import streamable_http_client
+from uipath._utils._ssl_context import get_httpx_client_kwargs
+from uipath.agent.models.agent import AgentMcpResourceConfig
+
+
+def _deduplicate_tools(tools: list[BaseTool]) -> list[BaseTool]:
+    """Deduplicate tools by appending numeric suffix to duplicate names."""
+    counts = Counter(tool.name for tool in tools)
+    seen: defaultdict[str, int] = defaultdict(int)
+
+    for tool in tools:
+        if counts[tool.name] > 1:
+            seen[tool.name] += 1
+            tool.name = f"{tool.name}_{seen[tool.name]}"
+
+    return tools
+
+
+def _filter_tools(tools: list[BaseTool], cfg: AgentMcpResourceConfig) -> list[BaseTool]:
+    """Filter tools to only include those in available_tools."""
+    allowed = {t.name for t in cfg.available_tools}
+    return [t for t in tools if t.name in allowed]
+
+
+@asynccontextmanager
+async def create_mcp_tools(
+    config: AgentMcpResourceConfig | list[AgentMcpResourceConfig],
+    max_concurrency: int = 5,
+):
+    """Connect to UiPath MCP server(s) and yield LangChain-compatible tools."""
+    if not (base_url := os.getenv("UIPATH_URL")):
+        raise ValueError("UIPATH_URL environment variable is not set")
+    if not (access_token := os.getenv("UIPATH_ACCESS_TOKEN")):
+        raise ValueError("UIPATH_ACCESS_TOKEN environment variable is not set")
+
+    configs = config if isinstance(config, list) else [config]
+    enabled = [c for c in configs if c.is_enabled is not False]
+
+    if not enabled:
+        yield []
+        return
+
+    base_url = base_url.rstrip("/")
+    semaphore = asyncio.Semaphore(max_concurrency)
+
+    default_client_kwargs = get_httpx_client_kwargs()
+    client_kwargs = {
+        **default_client_kwargs,
+        "headers": {"Authorization": f"Bearer {access_token}"},
+        "timeout": httpx.Timeout(60),
+    }
+
+    async def init_session(
+        session: ClientSession, cfg: AgentMcpResourceConfig
+    ) -> list[BaseTool]:
+        async with semaphore:
+            await session.initialize()
+            tools = await load_mcp_tools(session)
+            return _filter_tools(tools, cfg)
+
+    async def create_session(
+        stack: AsyncExitStack, cfg: AgentMcpResourceConfig
+    ) -> ClientSession:
+        url = f"{base_url}/agenthub_/mcp/{cfg.folder_path}/{cfg.slug}"
+        http_client = await stack.enter_async_context(
+            httpx.AsyncClient(**client_kwargs)
+        )
+        read, write, _ = await stack.enter_async_context(
+            streamable_http_client(url=url, http_client=http_client)
+        )
+        return await stack.enter_async_context(ClientSession(read, write))
+
+    async with AsyncExitStack() as stack:
+        sessions = [(await create_session(stack, cfg), cfg) for cfg in enabled]
+        results = await asyncio.gather(*[init_session(s, cfg) for s, cfg in sessions])
+        yield _deduplicate_tools(list(chain.from_iterable(results)))

uipath_langchain/agent/tools/process_tool.py

@@ -2,13 +2,14 @@
 
 from typing import Any
 
-from jsonschema_pydantic_converter import transform as create_model
 from langchain_core.tools import StructuredTool
 from langgraph.types import interrupt
 from uipath.agent.models.agent import AgentProcessToolResourceConfig
 from uipath.eval.mocks import mockable
 from uipath.platform.common import InvokeProcess
 
+from uipath_langchain.agent.react.jsonschema_pydantic_converter import create_model
+
 from .structured_tool_with_output_type import StructuredToolWithOutputType
 from .utils import sanitize_tool_name
 
@@ -27,6 +28,7 @@ def create_process_tool(resource: AgentProcessToolResourceConfig) -> StructuredT
         description=resource.description,
         input_schema=input_model.model_json_schema(),
         output_schema=output_model.model_json_schema(),
+        example_calls=resource.properties.example_calls,
     )
     async def process_tool_fn(**kwargs: Any):
         return interrupt(
@@ -44,6 +46,11 @@ def create_process_tool(resource: AgentProcessToolResourceConfig) -> StructuredT
         args_schema=input_model,
         coroutine=process_tool_fn,
         output_type=output_model,
+        metadata={
+            "tool_type": "process",
+            "display_name": process_name,
+            "folder_path": folder_path,
+        },
     )
 
     return tool

uipath_langchain/agent/tools/static_args.py

@@ -1,25 +1,27 @@
 """Handles static arguments for tool calls."""
 
-from typing import Any, Dict, List
+from typing import Any
 
 from jsonpath_ng import parse  # type: ignore[import-untyped]
-from langchain.tools import ToolRuntime
+from pydantic import BaseModel
 from uipath.agent.models.agent import (
     AgentIntegrationToolParameter,
     AgentIntegrationToolResourceConfig,
     BaseAgentResourceConfig,
 )
 
+from .utils import sanitize_dict_for_serialization
+
 
 def resolve_static_args(
     resource: BaseAgentResourceConfig,
-    agent_input: Dict[str, Any],
-) -> Dict[str, Any]:
+    agent_input: dict[str, Any],
+) -> dict[str, Any]:
     """Resolves static arguments for a given resource with a given input.
 
     Args:
         resource: The agent resource configuration.
-        input: Othe input arguments passed to the agent.
+        input: The input arguments passed to the agent.
 
     Returns:
         A dictionary of expanded arguments to be used in the tool call.
@@ -35,9 +37,9 @@ def resolve_static_args(
 
 
 def resolve_integration_static_args(
-    parameters: List[AgentIntegrationToolParameter],
-    agent_input: Dict[str, Any],
-) -> Dict[str, Any]:
+    parameters: list[AgentIntegrationToolParameter],
+    agent_input: dict[str, Any],
+) -> dict[str, Any]:
     """Resolves static arguments for an integration tool resource.
 
     Args:
@@ -48,7 +50,7 @@ def resolve_integration_static_args(
         A dictionary of expanded static arguments for the integration tool.
     """
 
-    static_args: Dict[str, Any] = {}
+    static_args: dict[str, Any] = {}
     for param in parameters:
         value = None
 
@@ -75,34 +77,10 @@ def resolve_integration_static_args(
     return static_args
 
 
-def sanitize_for_serialization(args: Dict[str, Any]) -> Dict[str, Any]:
-    """Convert Pydantic models in args to dicts."""
-    converted_args: Dict[str, Any] = {}
-    for key, value in args.items():
-        # handle Pydantic model
-        if hasattr(value, "model_dump"):
-            converted_args[key] = value.model_dump()
-
-        elif isinstance(value, list):
-            # handle list of Pydantic models
-            converted_list = []
-            for item in value:
-                if hasattr(item, "model_dump"):
-                    converted_list.append(item.model_dump())
-                else:
-                    converted_list.append(item)
-            converted_args[key] = converted_list
-
-        # handle regular value or unexpected type
-        else:
-            converted_args[key] = value
-    return converted_args
-
-
 def apply_static_args(
-    static_args: Dict[str, Any],
-    kwargs: Dict[str, Any],
-) -> Dict[str, Any]:
+    static_args: dict[str, Any],
+    kwargs: dict[str, Any],
+) -> dict[str, Any]:
     """Applies static arguments to the given input arguments.
 
     Args:
@@ -113,7 +91,7 @@ def apply_static_args(
         Merged input arguments with static arguments applied.
     """
 
-    sanitized_args = sanitize_for_serialization(kwargs)
+    sanitized_args = sanitize_dict_for_serialization(kwargs)
     for json_path, value in static_args.items():
         expr = parse(json_path)
         expr.update_or_create(sanitized_args, value)
@@ -122,8 +100,8 @@ def apply_static_args(
 
 
 def handle_static_args(
-    resource: BaseAgentResourceConfig, runtime: ToolRuntime, input_args: Dict[str, Any]
-) -> Dict[str, Any]:
+    resource: BaseAgentResourceConfig, state: BaseModel, input_args: dict[str, Any]
+) -> dict[str, Any]:
     """Resolves and applies static arguments for a tool call.
     Args:
         resource: The agent resource configuration.
@@ -133,6 +111,6 @@ def handle_static_args(
         A dictionary of input arguments with static arguments applied.
     """
 
-    static_args = resolve_static_args(resource, dict(runtime.state))
+    static_args = resolve_static_args(resource, dict(state))
     merged_args = apply_static_args(static_args, input_args)
     return merged_args

uipath_langchain/agent/tools/tool_factory.py

@@ -1,10 +1,12 @@
 """Factory functions for creating tools from agent resources."""
 
-from langchain_core.tools import BaseTool, StructuredTool
+from langchain_core.language_models import BaseChatModel
+from langchain_core.tools import BaseTool
 from uipath.agent.models.agent import (
     AgentContextResourceConfig,
     AgentEscalationResourceConfig,
     AgentIntegrationToolResourceConfig,
+    AgentInternalToolResourceConfig,
     AgentProcessToolResourceConfig,
     BaseAgentResourceConfig,
     LowCodeAgentDefinition,
@@ -13,14 +15,17 @@ from uipath.agent.models.agent import (
 from .context_tool import create_context_tool
 from .escalation_tool import create_escalation_tool
 from .integration_tool import create_integration_tool
+from .internal_tools import create_internal_tool
 from .process_tool import create_process_tool
 
 
-async def create_tools_from_resources(agent: LowCodeAgentDefinition) -> list[BaseTool]:
+async def create_tools_from_resources(
+    agent: LowCodeAgentDefinition, llm: BaseChatModel
+) -> list[BaseTool]:
     tools: list[BaseTool] = []
 
     for resource in agent.resources:
-        tool = await _build_tool_for_resource(resource)
+        tool = await _build_tool_for_resource(resource, llm)
         if tool is not None:
             tools.append(tool)
 
@@ -28,8 +33,8 @@ async def create_tools_from_resources(agent: LowCodeAgentDefinition) -> list[Bas
 
 
 async def _build_tool_for_resource(
-    resource: BaseAgentResourceConfig,
-) -> StructuredTool | None:
+    resource: BaseAgentResourceConfig, llm: BaseChatModel
+) -> BaseTool | None:
     if isinstance(resource, AgentProcessToolResourceConfig):
         return create_process_tool(resource)
 
@@ -42,4 +47,7 @@ async def _build_tool_for_resource(
     elif isinstance(resource, AgentIntegrationToolResourceConfig):
         return create_integration_tool(resource)
 
+    elif isinstance(resource, AgentInternalToolResourceConfig):
+        return create_internal_tool(resource, llm)
+
     return None