fix: support static arguments for integration tools (#639)

Author: ionut-mihalache-uipath

pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "uipath-langchain"
-version = "0.7.13"
+version = "0.7.14"
 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"
 dependencies = [
     "uipath>=2.10.0, <2.11.0",
     "uipath-core>=0.5.2, <0.6.0",
-    "uipath-platform>=0.0.4, <0.1.0",
+    "uipath-platform>=0.0.8, <0.1.0",
     "uipath-runtime>=0.9.1, <0.10.0",
     "langgraph>=1.0.0, <2.0.0",
     "langchain-core>=1.2.11, <2.0.0",

src/uipath_langchain/agent/tools/integration_tool.py

@@ -1,12 +1,19 @@
 """Process tool creation for UiPath process execution."""
 
 import copy
-from typing import Any
+import re
+from typing import Any, cast
 
 from langchain.tools import BaseTool
 from langchain_core.messages import ToolCall
 from langchain_core.tools import StructuredTool
-from uipath.agent.models.agent import AgentIntegrationToolResourceConfig
+from uipath.agent.models.agent import (
+    AgentIntegrationToolParameter,
+    AgentIntegrationToolResourceConfig,
+    AgentToolArgumentArgumentProperties,
+    AgentToolArgumentProperties,
+    AgentToolStaticArgumentProperties,
+)
 from uipath.eval.mocks import mockable
 from uipath.platform import UiPath
 from uipath.platform.connections import ActivityMetadata, ActivityParameterLocationInfo
@@ -15,18 +22,151 @@
 from uipath_langchain.agent.exceptions import AgentStartupError, AgentStartupErrorCode
 from uipath_langchain.agent.react.jsonschema_pydantic_converter import create_model
 from uipath_langchain.agent.react.types import AgentGraphState
-from uipath_langchain.agent.tools.static_args import handle_static_args
+from uipath_langchain.agent.tools.static_args import (
+    ArgumentPropertiesMixin,
+    handle_static_args,
+)
 from uipath_langchain.agent.tools.tool_node import (
-    ToolWrapperMixin,
     ToolWrapperReturnType,
 )
 
-from .structured_tool_with_output_type import StructuredToolWithOutputType
+from .schema_editing import strip_matching_enums
+from .structured_tool_with_argument_properties import (
+    StructuredToolWithArgumentProperties,
+)
 from .utils import sanitize_dict_for_serialization, sanitize_tool_name
 
 
-class StructuredToolWithWrapper(StructuredToolWithOutputType, ToolWrapperMixin):
-    pass
+def convert_integration_parameters_to_argument_properties(
+    parameters: list[AgentIntegrationToolParameter],
+) -> dict[str, AgentToolArgumentProperties]:
+    """Convert integration tool parameters to argument_properties format.
+
+    Converts parameters with fieldVariant 'static' or 'argument' to the
+    corresponding AgentToolArgumentProperties type. Parameters without
+    a recognized fieldVariant are skipped.
+
+    Args:
+        parameters: List of integration tool parameters to convert.
+
+    Returns:
+        Dictionary mapping JSONPath keys to argument properties.
+
+    Raises:
+        AgentStartupError: If an argument variant parameter has a malformed template.
+    """
+    result: dict[str, AgentToolArgumentProperties] = {}
+
+    for param in parameters:
+        if param.field_variant == "static":
+            key = _is_param_name_to_jsonpath(param.name)
+            result[key] = AgentToolStaticArgumentProperties(
+                is_sensitive=False,
+                value=param.value,
+            )
+        elif param.field_variant == "argument":
+            value_str = str(param.value) if param.value is not None else ""
+            match = _TEMPLATE_PATTERN.match(value_str)
+            if not match:
+                raise AgentStartupError(
+                    code=AgentStartupErrorCode.INVALID_TOOL_CONFIG,
+                    title="Malformed integration tool argument",
+                    detail=f"Argument parameter '{param.name}' has malformed template: "
+                    f"'{param.value}'. Expected format: '{{{{argName}}}}'",
+                    category=UiPathErrorCategory.USER,
+                )
+            arg_name = match.group(1)
+            key = _is_param_name_to_jsonpath(param.name)
+            result[key] = AgentToolArgumentArgumentProperties(
+                is_sensitive=False,
+                argument_path=arg_name,
+            )
+
+    return result
+
+
+_TEMPLATE_PATTERN = re.compile(r"^\{\{(.+?)\}\}$")
+
+
+def _param_name_to_segments(param_name: str) -> list[str]:
+    """Parse an Integration Service dot-notation parameter name into path segments.
+
+    Splits by '.' and expands '[*]' suffixes into a separate '*' wildcard segment.
+
+    Examples:
+        "channel"                             -> ["channel"]
+        "attachment.title"                    -> ["attachment", "title"]
+        "attachments[*].actions[*].confirm.text"
+            -> ["attachments", "*", "actions", "*", "confirm", "text"]
+    """
+    segments: list[str] = []
+    for part in param_name.split("."):
+        if part.endswith("[*]"):
+            segments.append(part[:-3])
+            segments.append("*")
+        else:
+            segments.append(part)
+    return segments
+
+
+def _escape_jsonpath_property(name: str) -> str:
+    """Escape a property name for bracket-notation JSONPath.
+
+    Per the JSONPath bracket-notation spec, escapes are applied in order:
+    1. Backslashes first: \\\\ -> \\\\\\\\
+    2. Single quotes second: ' -> \\\\'
+    """
+    return name.replace("\\", "\\\\").replace("'", "\\'")
+
+
+def _is_param_name_to_jsonpath(param_name: str) -> str:
+    """Convert an IS dot-notation parameter name to bracket-notation JSONPath.
+
+    Examples:
+        "channel"            -> "$['channel']"
+        "attachment.title"   -> "$['attachment']['title']"
+        "attachments[*].text" -> "$['attachments'][*]['text']"
+    """
+    segments = _param_name_to_segments(param_name)
+    parts: list[str] = []
+    for seg in segments:
+        if seg == "*":
+            parts.append("[*]")
+        else:
+            parts.append(f"['{_escape_jsonpath_property(seg)}']")
+    return "$" + "".join(parts)
+
+
+def strip_template_enums_from_schema(
+    schema: dict[str, Any],
+    parameters: list[AgentIntegrationToolParameter],
+) -> dict[str, Any]:
+    """Remove {{template}} enum values only from argument-variant parameter fields.
+
+    For each parameter with fieldVariant 'argument', navigates the schema to the
+    corresponding field (supporting nested objects, arrays, and $ref resolution)
+    and strips enum values matching the {{...}} pattern.
+
+    The function deep-copies the schema so the original is never mutated.
+
+    Args:
+        schema: A JSON-schema-style dictionary (the tool's inputSchema).
+        parameters: List of integration tool parameters from resource.properties.
+
+    Returns:
+        A cleaned copy of the schema with template enum values removed
+        only from argument-variant fields.
+    """
+    schema = copy.deepcopy(schema)
+
+    for param in parameters:
+        if param.field_variant != "argument":
+            continue
+
+        segments = _param_name_to_segments(param.name)
+        strip_matching_enums(schema, segments, _TEMPLATE_PATTERN)
+
+    return schema
 
 
 def remove_asterisk_from_properties(fields: dict[str, Any]) -> dict[str, Any]:
@@ -155,14 +295,21 @@ def create_integration_tool(
 
     activity_metadata = convert_to_activity_metadata(resource)
 
-    input_model = create_model(resource.input_schema)
+    cleaned_input_schema = strip_template_enums_from_schema(
+        resource.input_schema, resource.properties.parameters
+    )
+    input_model = create_model(cleaned_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": {}})
     )
 
+    argument_properties = convert_integration_parameters_to_argument_properties(
+        resource.properties.parameters
+    )
+
     sdk = UiPath()
 
     @mockable(
@@ -189,10 +336,12 @@ async def integration_tool_wrapper(
         call: ToolCall,
         state: AgentGraphState,
     ) -> ToolWrapperReturnType:
-        call["args"] = handle_static_args(resource, state, call["args"])
+        call["args"] = handle_static_args(
+            cast(ArgumentPropertiesMixin, tool), state, call["args"]
+        )
         return await tool.ainvoke(call)
 
-    tool = StructuredToolWithWrapper(
+    tool = StructuredToolWithArgumentProperties(
         name=tool_name,
         description=resource.description,
         args_schema=input_model,
@@ -204,6 +353,7 @@ async def integration_tool_wrapper(
             "connector_key": resource.properties.connection.id,
             "connector_name": resource.properties.connection.name,
         },
+        argument_properties=argument_properties,
     )
     tool.set_tool_wrappers(awrapper=integration_tool_wrapper)
 

src/uipath_langchain/agent/tools/schema_editing.py

@@ -2,6 +2,7 @@
 
 import copy
 import json
+import re
 from typing import Any
 
 from jsonpath_ng import (  # type: ignore[import-untyped]
@@ -108,6 +109,37 @@ def _navigate_schema_inlining_refs(
     return current
 
 
+def strip_matching_enums(
+    schema: dict[str, Any],
+    path_segments: list[str],
+    pattern: re.Pattern[str],
+) -> None:
+    """Navigate to a field in schema and remove enum values matching the pattern.
+
+    If the path doesn't exist in the schema, this is a no-op.
+    After removing matching values, if the enum becomes empty, the enum key is deleted.
+
+    Args:
+        schema: The root JSON schema (modified in place).
+        path_segments: Path segments to navigate to the field.
+        pattern: Compiled regex pattern to match enum values against.
+    """
+    try:
+        field_schema = _navigate_schema_inlining_refs(schema, path_segments)
+    except SchemaModificationError:
+        return
+
+    enum = field_schema.get("enum")
+    if enum is None:
+        return
+
+    cleaned = [v for v in enum if not (isinstance(v, str) and pattern.match(v))]
+    if not cleaned:
+        del field_schema["enum"]
+    else:
+        field_schema["enum"] = cleaned
+
+
 def _apply_sensitive_schema_modification(
     schema: dict[str, Any],
     path_parts: list[str],

src/uipath_langchain/agent/tools/static_args.py

@@ -8,8 +8,6 @@
 from langchain_core.tools import StructuredTool
 from pydantic import BaseModel
 from uipath.agent.models.agent import (
-    AgentIntegrationToolParameter,
-    AgentIntegrationToolResourceConfig,
     AgentToolArgumentArgumentProperties,
     AgentToolArgumentProperties,
     AgentToolStaticArgumentProperties,
@@ -137,24 +135,20 @@ def apply_static_argument_properties_to_schema(
 
 
 def resolve_static_args(
-    resource: BaseAgentResourceConfig,
+    resource: BaseAgentResourceConfig | ArgumentPropertiesMixin,
     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: The input arguments passed to the agent.
+        resource: The agent resource configuration or tool with argument_properties.
+        agent_input: The input arguments passed to the agent.
 
     Returns:
         A dictionary of expanded arguments to be used in the tool call.
     """
 
-    if isinstance(resource, AgentIntegrationToolResourceConfig):
-        return resolve_integration_static_args(
-            resource.properties.parameters, agent_input
-        )
-    elif hasattr(resource, "argument_properties"):
+    if hasattr(resource, "argument_properties"):
         # TODO: MCP tools don't inherit from BaseAgentResourceConfig; will need to handle separately
         static_arguments = _resolve_argument_properties_to_static_arguments(
             resource.argument_properties, agent_input
@@ -167,47 +161,6 @@ def resolve_static_args(
         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 apply_static_args(
     static_args: dict[str, Any],
     kwargs: dict[str, Any],
@@ -244,12 +197,14 @@ def apply_static_args(
 
 
 def handle_static_args(
-    resource: BaseAgentResourceConfig, state: BaseModel, input_args: dict[str, Any]
+    resource: BaseAgentResourceConfig | ArgumentPropertiesMixin,
+    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.
-        runtime: The tool runtime providing the current state.
+        resource: The agent resource configuration or tool with argument_properties.
+        state: The current agent state.
         input_args: The original input arguments to the tool.
     Returns:
         A dictionary of input arguments with static arguments applied.