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

uipath_langchain/agent/tools/integration_tool.py

@@ -0,0 +1,181 @@
+"""Process tool creation for UiPath process execution."""
+
+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 .structured_tool_with_output_type import StructuredToolWithOutputType
+from .utils import sanitize_tool_name
+
+
+def remove_asterisk_from_properties(fields: dict[str, Any]) -> dict[str, Any]:
+    """
+    Fix bug in integration service.
+    """
+    fields = copy.deepcopy(fields)
+
+    def fix_types(props: dict[str, Any]) -> None:
+        type_ = props.get("type", None)
+        if "$ref" in props:
+            props["$ref"] = props["$ref"].replace("[*]", "")
+        if type_ == "object":
+            properties = {}
+            for k, v in props.get("properties", {}).items():
+                # Remove asterisks!
+                k = k.replace("[*]", "")
+                properties[k] = v
+                if isinstance(v, dict):
+                    fix_types(v)
+            if "properties" in props:
+                props["properties"] = properties
+        if type_ == "array":
+            fix_types(props.get("items", {}))
+
+    definitions = {}
+    for k, value in fields.get("$defs", fields.get("definitions", {})).items():
+        k = k.replace("[*]", "")
+        definitions[k] = value
+        fix_types(value)
+    if "definitions" in fields:
+        fields["definitions"] = definitions
+
+    fix_types(fields)
+    return fields
+
+
+def extract_top_level_field(param_name: str) -> str:
+    """Extract the top-level field name from a jsonpath parameter name.
+
+    Examples:
+        metadata.field.test -> metadata
+        attachments[*] -> attachments
+        attachments[0].filename -> attachments
+        simple_field -> simple_field
+    """
+    # Split by '.' to get the first part
+    first_part = param_name.split(".")[0]
+
+    # Remove array notation if present (e.g., "attachments[*]" -> "attachments")
+    if "[" in first_part:
+        first_part = first_part.split("[")[0]
+
+    return first_part
+
+
+def convert_to_activity_metadata(
+    resource: AgentIntegrationToolResourceConfig,
+) -> ActivityMetadata:
+    """Convert AgentIntegrationToolResourceConfig to ActivityMetadata."""
+
+    # normalize HTTP method (GETBYID -> GET)
+    http_method = resource.properties.method
+    if http_method == "GETBYID":
+        http_method = "GET"
+
+    param_location_info = ActivityParameterLocationInfo()
+    # because of nested fields and array notation, use a set to avoid duplicates
+    body_fields_set = set()
+
+    # mapping parameter locations
+    for param in resource.properties.parameters:
+        param_name = param.name
+        field_location = param.field_location
+
+        if field_location == "query":
+            param_location_info.query_params.append(param_name)
+        elif field_location == "path":
+            param_location_info.path_params.append(param_name)
+        elif field_location == "header":
+            param_location_info.header_params.append(param_name)
+        elif field_location in ("multipart", "file"):
+            param_location_info.multipart_params.append(param_name)
+        elif field_location == "body":
+            # extract top-level field from jsonpath parameter name
+            top_level_field = extract_top_level_field(param_name)
+            body_fields_set.add(top_level_field)
+        else:
+            # default to body field - extract top-level field
+            top_level_field = extract_top_level_field(param_name)
+            body_fields_set.add(top_level_field)
+
+    param_location_info.body_fields = list(body_fields_set)
+
+    # determine content type
+    content_type = "application/json"
+    if resource.properties.body_structure is not None:
+        shorthand_type = resource.properties.body_structure.get("contentType", "json")
+        if shorthand_type == "multipart":
+            content_type = "multipart/form-data"
+
+    return ActivityMetadata(
+        object_path=resource.properties.tool_path,
+        method_name=http_method,
+        content_type=content_type,
+        parameter_location_info=param_location_info,
+    )
+
+
+def create_integration_tool(
+    resource: AgentIntegrationToolResourceConfig,
+) -> StructuredTool:
+    """Creates a StructuredTool for invoking an Integration Service connector activity."""
+    tool_name: str = sanitize_tool_name(resource.name)
+    if resource.properties.connection.id is None:
+        raise ValueError("Connection ID cannot be None for integration tool.")
+    connection_id: str = resource.properties.connection.id
+
+    activity_metadata = convert_to_activity_metadata(resource)
+
+    input_model = create_model(resource.input_schema)
+    # note: IS tools output schemas were recently added and are most likely not present in all resources
+    output_model: Any = (
+        create_model(remove_asterisk_from_properties(resource.output_schema))
+        if resource.output_schema
+        else create_model({"type": "object", "properties": {}})
+    )
+
+    sdk = UiPath()
+
+    @mockable(
+        name=resource.name,
+        description=resource.description,
+        input_schema=input_model.model_json_schema(),
+        output_schema=output_model.model_json_schema(),
+    )
+    async def integration_tool_fn(runtime: ToolRuntime, **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,
+            )
+        except Exception:
+            raise
+
+        return result
+
+    tool = StructuredToolWithOutputType(
+        name=tool_name,
+        description=resource.description,
+        args_schema=resource.input_schema,
+        coroutine=integration_tool_fn,
+        output_type=output_model,
+    )
+
+    return tool

uipath_langchain/agent/tools/process_tool.py

@@ -0,0 +1,49 @@
+"""Process tool creation for UiPath process execution."""
+
+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 .structured_tool_with_output_type import StructuredToolWithOutputType
+from .utils import sanitize_tool_name
+
+
+def create_process_tool(resource: AgentProcessToolResourceConfig) -> StructuredTool:
+    """Uses interrupt() to suspend graph execution until process completes (handled by runtime)."""
+    tool_name: str = sanitize_tool_name(resource.name)
+    process_name = resource.properties.process_name
+    folder_path = resource.properties.folder_path
+
+    input_model: Any = create_model(resource.input_schema)
+    output_model: Any = 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 process_tool_fn(**kwargs: Any):
+        return interrupt(
+            InvokeProcess(
+                name=process_name,
+                input_arguments=kwargs,
+                process_folder_path=folder_path,
+                process_folder_key=None,
+            )
+        )
+
+    tool = StructuredToolWithOutputType(
+        name=tool_name,
+        description=resource.description,
+        args_schema=input_model,
+        coroutine=process_tool_fn,
+        output_type=output_model,
+    )
+
+    return tool

uipath_langchain/agent/tools/static_args.py

@@ -0,0 +1,138 @@
+"""Handles static arguments for tool calls."""
+
+from typing import Any, Dict, List
+
+from jsonpath_ng import parse  # type: ignore[import-untyped]
+from langchain.tools import ToolRuntime
+from uipath.agent.models.agent import (
+    AgentIntegrationToolParameter,
+    AgentIntegrationToolResourceConfig,
+    BaseAgentResourceConfig,
+)
+
+
+def resolve_static_args(
+    resource: BaseAgentResourceConfig,
+    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.
+
+    Returns:
+        A dictionary of expanded arguments to be used in the tool call.
+    static_args: Dict[str, Any] = {}
+    """
+
+    if isinstance(resource, AgentIntegrationToolResourceConfig):
+        return resolve_integration_static_args(
+            resource.properties.parameters, agent_input
+        )
+    else:
+        return {}  # to be implemented for other resource types in the future
+
+
+def resolve_integration_static_args(
+    parameters: List[AgentIntegrationToolParameter],
+    agent_input: Dict[str, Any],
+) -> Dict[str, Any]:
+    """Resolves static arguments for an integration tool resource.
+
+    Args:
+        resource: The AgentIntegrationToolResourceConfig instance.
+        input: The input arguments passed to the agent.
+
+    Returns:
+        A dictionary of expanded static arguments for the integration tool.
+    """
+
+    static_args: Dict[str, Any] = {}
+    for param in parameters:
+        value = None
+
+        # static parameter, use the defined static value
+        if param.field_variant == "static":
+            value = param.value
+        # argument parameter, extract value from agent input
+        elif param.field_variant == "argument":
+            if (
+                not isinstance(param.value, str)
+                or not param.value.startswith("{{")
+                or not param.value.endswith("}}")
+            ):
+                raise ValueError(
+                    f"Parameter value must be in the format '{{argument_name}}' when field_variant is 'argument', got {param.value}"
+                )
+            arg_name = param.value[2:-2].strip()
+            # currently only support top-level arguments
+            value = agent_input.get(arg_name)
+
+        if value is not None:
+            static_args[param.name] = value
+
+    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]:
+    """Applies static arguments to the given input arguments.
+
+    Args:
+        static_args: Dictionary of static arguments {json_path: value} to apply.
+        kwargs: Original input arguments to the tool.
+
+    Returns:
+        Merged input arguments with static arguments applied.
+    """
+
+    sanitized_args = sanitize_for_serialization(kwargs)
+    for json_path, value in static_args.items():
+        expr = parse(json_path)
+        expr.update_or_create(sanitized_args, value)
+
+    return sanitized_args
+
+
+def handle_static_args(
+    resource: BaseAgentResourceConfig, runtime: ToolRuntime, input_args: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Resolves and applies static arguments for a tool call.
+    Args:
+        resource: The agent resource configuration.
+        runtime: The tool runtime providing the current state.
+        input_args: The original input arguments to the tool.
+    Returns:
+        A dictionary of input arguments with static arguments applied.
+    """
+
+    static_args = resolve_static_args(resource, dict(runtime.state))
+    merged_args = apply_static_args(static_args, input_args)
+    return merged_args

uipath_langchain/agent/tools/structured_tool_with_output_type.py

@@ -0,0 +1,14 @@
+from typing import Any
+
+from langchain_core.tools import StructuredTool
+from pydantic import Field
+from typing_extensions import override
+
+
+class StructuredToolWithOutputType(StructuredTool):
+    output_type: Any = Field(Any, description="Output type.")
+
+    @override
+    @property
+    def OutputType(self) -> type[Any]:
+        return self.output_type

uipath_langchain/agent/tools/tool_factory.py

@@ -0,0 +1,45 @@
+"""Factory functions for creating tools from agent resources."""
+
+from langchain_core.tools import BaseTool, StructuredTool
+from uipath.agent.models.agent import (
+    AgentContextResourceConfig,
+    AgentEscalationResourceConfig,
+    AgentIntegrationToolResourceConfig,
+    AgentProcessToolResourceConfig,
+    BaseAgentResourceConfig,
+    LowCodeAgentDefinition,
+)
+
+from .context_tool import create_context_tool
+from .escalation_tool import create_escalation_tool
+from .integration_tool import create_integration_tool
+from .process_tool import create_process_tool
+
+
+async def create_tools_from_resources(agent: LowCodeAgentDefinition) -> list[BaseTool]:
+    tools: list[BaseTool] = []
+
+    for resource in agent.resources:
+        tool = await _build_tool_for_resource(resource)
+        if tool is not None:
+            tools.append(tool)
+
+    return tools
+
+
+async def _build_tool_for_resource(
+    resource: BaseAgentResourceConfig,
+) -> StructuredTool | None:
+    if isinstance(resource, AgentProcessToolResourceConfig):
+        return create_process_tool(resource)
+
+    elif isinstance(resource, AgentContextResourceConfig):
+        return create_context_tool(resource)
+
+    elif isinstance(resource, AgentEscalationResourceConfig):
+        return create_escalation_tool(resource)
+
+    elif isinstance(resource, AgentIntegrationToolResourceConfig):
+        return create_integration_tool(resource)
+
+    return None

uipath_langchain/agent/tools/tool_node.py

@@ -0,0 +1,22 @@
+"""Tool node factory wiring directly to LangGraph's ToolNode."""
+
+from collections.abc import Sequence
+
+from langchain_core.tools import BaseTool
+from langgraph.prebuilt import ToolNode
+
+
+def create_tool_node(tools: Sequence[BaseTool]) -> dict[str, ToolNode]:
+    """Create individual ToolNode for each tool.
+
+    Args:
+        tools: Sequence of tools to create nodes for.
+
+    Returns:
+        Dict mapping tool.name -> ToolNode([tool]).
+        Each tool gets its own dedicated node for middleware composition.
+
+    Note:
+        handle_tool_errors=False delegates error handling to LangGraph's error boundary.
+    """
+    return {tool.name: ToolNode([tool], handle_tool_errors=False) for tool in tools}

uipath_langchain/agent/tools/utils.py

@@ -0,0 +1,11 @@
+"""Tool-related utility functions."""
+
+import re
+
+
+def sanitize_tool_name(name: str) -> str:
+    """Sanitize tool name for LLM compatibility (alphanumeric, underscore, hyphen only, max 64 chars)."""
+    trim_whitespaces = "_".join(name.split())
+    sanitized_tool_name = re.sub(r"[^a-zA-Z0-9_-]", "", trim_whitespaces)
+    sanitized_tool_name = sanitized_tool_name[:64]
+    return sanitized_tool_name

uipath_langchain/chat/__init__.py

@@ -1,6 +1,10 @@
+from .mapper import UiPathChatMessagesMapper
 from .models import UiPathAzureChatOpenAI, UiPathChat
+from .openai import UiPathChatOpenAI
 
 __all__ = [
     "UiPathChat",
     "UiPathAzureChatOpenAI",
+    "UiPathChatOpenAI",
+    "UiPathChatMessagesMapper",
 ]

uipath_langchain/chat/bedrock.py

@@ -0,0 +1,187 @@
+import logging
+import os
+from typing import Optional
+
+from uipath.utils import EndpointManager
+
+from .supported_models import BedrockModels
+
+logger = logging.getLogger(__name__)
+
+
+def _check_bedrock_dependencies() -> None:
+    """Check if required dependencies for UiPathChatBedrock are installed."""
+    import importlib.util
+
+    missing_packages = []
+
+    if importlib.util.find_spec("langchain_aws") is None:
+        missing_packages.append("langchain-aws")
+
+    if importlib.util.find_spec("boto3") is None:
+        missing_packages.append("boto3")
+
+    if missing_packages:
+        packages_str = ", ".join(missing_packages)
+        raise ImportError(
+            f"The following packages are required to use UiPathChatBedrock: {packages_str}\n"
+            "Please install them using one of the following methods:\n\n"
+            "  # Using pip:\n"
+            f"  pip install uipath-langchain[bedrock]\n\n"
+            "  # Using uv:\n"
+            f"  uv add 'uipath-langchain[bedrock]'\n\n"
+        )
+
+
+_check_bedrock_dependencies()
+
+import boto3
+from langchain_aws import (
+    ChatBedrock,
+    ChatBedrockConverse,
+)
+
+
+class AwsBedrockCompletionsPassthroughClient:
+    def __init__(
+        self,
+        model: str,
+        token: str,
+        api_flavor: str,
+    ):
+        self.model = model
+        self.token = token
+        self.api_flavor = api_flavor
+        self._vendor = "awsbedrock"
+        self._url: Optional[str] = None
+
+    @property
+    def endpoint(self) -> str:
+        vendor_endpoint = EndpointManager.get_vendor_endpoint()
+        formatted_endpoint = vendor_endpoint.format(
+            vendor=self._vendor,
+            model=self.model,
+        )
+        return formatted_endpoint
+
+    def _build_base_url(self) -> str:
+        if not self._url:
+            env_uipath_url = os.getenv("UIPATH_URL")
+
+            if env_uipath_url:
+                self._url = f"{env_uipath_url.rstrip('/')}/{self.endpoint}"
+            else:
+                raise ValueError("UIPATH_URL environment variable is required")
+
+        return self._url
+
+    def get_client(self):
+        client = boto3.client(
+            "bedrock-runtime",
+            region_name="none",
+            aws_access_key_id="none",
+            aws_secret_access_key="none",
+        )
+        client.meta.events.register(
+            "before-send.bedrock-runtime.*", self._modify_request
+        )
+        return client
+
+    def _modify_request(self, request, **kwargs):
+        """Intercept boto3 request and redirect to LLM Gateway"""
+        # Detect streaming based on URL suffix:
+        # - converse-stream / invoke-with-response-stream -> streaming
+        # - converse / invoke -> non-streaming
+        streaming = "true" if request.url.endswith("-stream") else "false"
+        request.url = self._build_base_url()
+
+        headers = {
+            "Authorization": f"Bearer {self.token}",
+            "X-UiPath-LlmGateway-ApiFlavor": self.api_flavor,
+            "X-UiPath-Streaming-Enabled": streaming,
+        }
+
+        job_key = os.getenv("UIPATH_JOB_KEY")
+        process_key = os.getenv("UIPATH_PROCESS_KEY")
+        if job_key:
+            headers["X-UiPath-JobKey"] = job_key
+        if process_key:
+            headers["X-UiPath-ProcessKey"] = process_key
+
+        request.headers.update(headers)
+
+
+class UiPathChatBedrockConverse(ChatBedrockConverse):
+    def __init__(
+        self,
+        org_id: Optional[str] = None,
+        tenant_id: Optional[str] = None,
+        token: Optional[str] = None,
+        model_name: str = BedrockModels.anthropic_claude_haiku_4_5,
+        **kwargs,
+    ):
+        org_id = org_id or os.getenv("UIPATH_ORGANIZATION_ID")
+        tenant_id = tenant_id or os.getenv("UIPATH_TENANT_ID")
+        token = token or os.getenv("UIPATH_ACCESS_TOKEN")
+
+        if not org_id:
+            raise ValueError(
+                "UIPATH_ORGANIZATION_ID environment variable or org_id parameter is required"
+            )
+        if not tenant_id:
+            raise ValueError(
+                "UIPATH_TENANT_ID environment variable or tenant_id parameter is required"
+            )
+        if not token:
+            raise ValueError(
+                "UIPATH_ACCESS_TOKEN environment variable or token parameter is required"
+            )
+
+        passthrough_client = AwsBedrockCompletionsPassthroughClient(
+            model=model_name,
+            token=token,
+            api_flavor="converse",
+        )
+
+        client = passthrough_client.get_client()
+        kwargs["client"] = client
+        kwargs["model"] = model_name
+        super().__init__(**kwargs)
+
+
+class UiPathChatBedrock(ChatBedrock):
+    def __init__(
+        self,
+        org_id: Optional[str] = None,
+        tenant_id: Optional[str] = None,
+        token: Optional[str] = None,
+        model_name: str = BedrockModels.anthropic_claude_haiku_4_5,
+        **kwargs,
+    ):
+        org_id = org_id or os.getenv("UIPATH_ORGANIZATION_ID")
+        tenant_id = tenant_id or os.getenv("UIPATH_TENANT_ID")
+        token = token or os.getenv("UIPATH_ACCESS_TOKEN")
+
+        if not org_id:
+            raise ValueError(
+                "UIPATH_ORGANIZATION_ID environment variable or org_id parameter is required"
+            )
+        if not tenant_id:
+            raise ValueError(
+                "UIPATH_TENANT_ID environment variable or tenant_id parameter is required"
+            )
+        if not token:
+            raise ValueError(
+                "UIPATH_ACCESS_TOKEN environment variable or token parameter is required"
+            )
+
+        passthrough_client = AwsBedrockCompletionsPassthroughClient(
+            model=model_name,
+            token=token,
+            api_flavor="invoke",
+        )
+
+        client = passthrough_client.get_client()
+        kwargs["client"] = client
+        kwargs["model"] = model_name
+        super().__init__(**kwargs)