uipath-langchain 0.1.24__py3-none-any.whl → 0.1.34__py3-none-any.whl

uipath_langchain/_utils/_request_mixin.py

@@ -137,6 +137,8 @@ class UiPathRequestMixin(BaseModel):
     max_tokens: int | None = 1000
     frequency_penalty: float | None = None
     presence_penalty: float | None = None
+    agenthub_config: str | None = None
+    byo_connection_id: str | None = None
 
     logger: logging.Logger | None = None
     max_retries: int | None = 5
@@ -748,6 +750,12 @@ class UiPathRequestMixin(BaseModel):
                 "Authorization": f"Bearer {self.access_token}",
                 "X-UiPath-LlmGateway-TimeoutSeconds": str(self.default_request_timeout),
             }
+            if self.agenthub_config:
+                self._auth_headers["X-UiPath-AgentHub-Config"] = self.agenthub_config
+            if self.byo_connection_id:
+                self._auth_headers["X-UiPath-LlmGateway-ByoIsConnectionId"] = (
+                    self.byo_connection_id
+                )
             if self.is_normalized and self.model_name:
                 self._auth_headers["X-UiPath-LlmGateway-NormalizedApi-ModelName"] = (
                     self.model_name

uipath_langchain/_utils/_settings.py

@@ -5,6 +5,7 @@ from typing import Any
 import httpx
 from pydantic import Field
 from pydantic_settings import BaseSettings
+from uipath._utils._ssl_context import get_httpx_client_kwargs
 
 
 class UiPathCachedPathsSettings(BaseSettings):
@@ -58,7 +59,7 @@ def get_uipath_token_header(
             client_secret=settings.client_secret,
             grant_type="client_credentials",
         )
-        with httpx.Client() as client:
+        with httpx.Client(**get_httpx_client_kwargs()) as client:
             res = client.post(url_get_token, data=token_credentials)
             res_json = res.json()
             uipath_token_header = res_json.get("access_token")
@@ -79,7 +80,7 @@ async def get_token_header_async(
             grant_type="client_credentials",
         )
 
-        with httpx.Client() as client:
+        with httpx.Client(**get_httpx_client_kwargs()) as client:
             res_json = client.post(url_get_token, data=token_credentials).json()
             uipath_token_header = res_json.get("access_token")
 

uipath_langchain/agent/guardrails/__init__.py

@@ -1,21 +1,5 @@
-from .guardrail_nodes import (
-    create_agent_guardrail_node,
-    create_llm_guardrail_node,
-    create_tool_guardrail_node,
-)
 from .guardrails_factory import build_guardrails_with_actions
-from .guardrails_subgraph import (
-    create_agent_guardrails_subgraph,
-    create_llm_guardrails_subgraph,
-    create_tool_guardrails_subgraph,
-)
 
 __all__ = [
-    "create_llm_guardrails_subgraph",
-    "create_agent_guardrails_subgraph",
-    "create_tool_guardrails_subgraph",
-    "create_llm_guardrail_node",
-    "create_agent_guardrail_node",
-    "create_tool_guardrail_node",
     "build_guardrails_with_actions",
 ]

uipath_langchain/agent/guardrails/actions/__init__.py

@@ -1,6 +1,7 @@
 from .base_action import GuardrailAction
 from .block_action import BlockAction
 from .escalate_action import EscalateAction
+from .filter_action import FilterAction
 from .log_action import LogAction
 
 __all__ = [
@@ -8,4 +9,5 @@ __all__ = [
     "BlockAction",
     "LogAction",
     "EscalateAction",
+    "FilterAction",
 ]

uipath_langchain/agent/guardrails/actions/base_action.py

@@ -18,6 +18,7 @@ class GuardrailAction(ABC):
         guardrail: BaseGuardrail,
         scope: GuardrailScope,
         execution_stage: ExecutionStage,
+        guarded_component_name: str,
     ) -> GuardrailActionNode:
         """Create and return the Action node to execute on validation failure."""
         ...

uipath_langchain/agent/guardrails/actions/block_action.py

@@ -6,7 +6,7 @@ from uipath.runtime.errors import UiPathErrorCategory, UiPathErrorCode
 from uipath_langchain.agent.guardrails.types import ExecutionStage
 
 from ...exceptions import AgentTerminationException
-from ..types import AgentGuardrailsGraphState
+from ...react.types import AgentGuardrailsGraphState
 from .base_action import GuardrailAction, GuardrailActionNode
 
 
@@ -26,6 +26,7 @@ class BlockAction(GuardrailAction):
         guardrail: BaseGuardrail,
         scope: GuardrailScope,
         execution_stage: ExecutionStage,
+        guarded_component_name: str,
     ) -> GuardrailActionNode:
         raw_node_name = f"{scope.name}_{execution_stage.name}_{guardrail.name}_block"
         node_name = re.sub(r"\W+", "_", raw_node_name.lower()).strip("_")

uipath_langchain/agent/guardrails/actions/escalate_action.py

@@ -14,8 +14,9 @@ from uipath.platform.guardrails import (
 from uipath.runtime.errors import UiPathErrorCode
 
 from ...exceptions import AgentTerminationException
-from ..guardrail_nodes import _message_text
-from ..types import AgentGuardrailsGraphState, ExecutionStage
+from ...react.types import AgentGuardrailsGraphState
+from ..types import ExecutionStage
+from ..utils import _extract_tool_args_from_message, get_message_content
 from .base_action import GuardrailAction, GuardrailActionNode
 
 
@@ -34,6 +35,14 @@ class EscalateAction(GuardrailAction):
         version: int,
         assignee: str,
     ):
+        """Initialize EscalateAction with escalation app configuration.
+
+        Args:
+            app_name: Name of the escalation app.
+            app_folder_path: Folder path where the escalation app is located.
+            version: Version of the escalation app.
+            assignee: User or role assigned to handle the escalation.
+        """
         self.app_name = app_name
         self.app_folder_path = app_folder_path
         self.version = version
@@ -45,13 +54,27 @@ class EscalateAction(GuardrailAction):
         guardrail: BaseGuardrail,
         scope: GuardrailScope,
         execution_stage: ExecutionStage,
+        guarded_component_name: str,
     ) -> GuardrailActionNode:
+        """Create a HITL escalation node for the guardrail.
+
+        Args:
+            guardrail: The guardrail that triggered this escalation action.
+            scope: The guardrail scope (LLM/AGENT/TOOL).
+            execution_stage: The execution stage (PRE_EXECUTION or POST_EXECUTION).
+
+        Returns:
+            A tuple of (node_name, node_function) where the node function triggers
+            a HITL interruption and processes the escalation response.
+        """
         node_name = _get_node_name(execution_stage, guardrail, scope)
 
         async def _node(
             state: AgentGuardrailsGraphState,
         ) -> Dict[str, Any] | Command[Any]:
-            input = _extract_escalation_content(state, scope, execution_stage)
+            input = _extract_escalation_content(
+                state, scope, execution_stage, guarded_component_name
+            )
             escalation_field = _execution_stage_to_escalation_field(execution_stage)
 
             data = {
@@ -75,7 +98,11 @@ class EscalateAction(GuardrailAction):
 
             if escalation_result.action == "Approve":
                 return _process_escalation_response(
-                    state, escalation_result.data, scope, execution_stage
+                    state,
+                    escalation_result.data,
+                    scope,
+                    execution_stage,
+                    guarded_component_name,
                 )
 
             raise AgentTerminationException(
@@ -95,46 +122,58 @@ def _get_node_name(
     return node_name
 
 
-def _execution_stage_to_string(
+def _process_escalation_response(
+    state: AgentGuardrailsGraphState,
+    escalation_result: Dict[str, Any],
+    scope: GuardrailScope,
     execution_stage: ExecutionStage,
-) -> Literal["PreExecution", "PostExecution"]:
-    """Convert ExecutionStage enum to string literal.
+    guarded_node_name: str,
+) -> Dict[str, Any] | Command[Any]:
+    """Process escalation response and route to appropriate handler based on scope.
 
     Args:
-        execution_stage: The execution stage enum.
+        state: The current agent graph state.
+        escalation_result: The result from the escalation interrupt containing reviewed inputs/outputs.
+        scope: The guardrail scope (LLM/AGENT/TOOL).
+        execution_stage: The execution stage (PRE_EXECUTION or POST_EXECUTION).
 
     Returns:
-        "PreExecution" for PRE_EXECUTION, "PostExecution" for POST_EXECUTION.
+        For LLM/TOOL scope: Command to update messages with reviewed inputs/outputs, or empty dict.
+        For AGENT scope: Empty dict (no message alteration).
     """
-    if execution_stage == ExecutionStage.PRE_EXECUTION:
-        return "PreExecution"
-    return "PostExecution"
+    match scope:
+        case GuardrailScope.LLM:
+            return _process_llm_escalation_response(
+                state, escalation_result, execution_stage
+            )
+        case GuardrailScope.TOOL:
+            return _process_tool_escalation_response(
+                state, escalation_result, execution_stage, guarded_node_name
+            )
+        case GuardrailScope.AGENT:
+            return {}
 
 
-def _process_escalation_response(
+def _process_llm_escalation_response(
     state: AgentGuardrailsGraphState,
     escalation_result: Dict[str, Any],
-    scope: GuardrailScope,
     execution_stage: ExecutionStage,
 ) -> Dict[str, Any] | Command[Any]:
-    """Process escalation response and update state based on guardrail scope.
+    """Process escalation response for LLM scope guardrails.
+
+    Updates message content or tool calls based on reviewed inputs/outputs from escalation.
 
     Args:
         state: The current agent graph state.
-        escalation_result: The result from the escalation interrupt.
-        scope: The guardrail scope (LLM/AGENT/TOOL).
-        execution_stage: The hook type ("PreExecution" or "PostExecution").
+        escalation_result: The result from the escalation interrupt containing reviewed inputs/outputs.
+        execution_stage: The execution stage (PRE_EXECUTION or POST_EXECUTION).
 
     Returns:
-        For LLM scope: Command to update messages with reviewed inputs/outputs.
-        For non-LLM scope: Empty dict (no message alteration).
+        Command to update messages with reviewed inputs/outputs, or empty dict if no updates needed.
 
     Raises:
         AgentTerminationException: If escalation response processing fails.
     """
-    if scope != GuardrailScope.LLM:
-        return {}
-
     try:
         reviewed_field = (
             "ReviewedInputs"
@@ -191,7 +230,93 @@ def _process_escalation_response(
                 if content_list:
                     last_message.content = content_list[-1]
 
-        return Command[Any](update={"messages": msgs})
+        return Command(update={"messages": msgs})
+    except Exception as e:
+        raise AgentTerminationException(
+            code=UiPathErrorCode.EXECUTION_ERROR,
+            title="Escalation rejected",
+            detail=str(e),
+        ) from e
+
+
+def _process_tool_escalation_response(
+    state: AgentGuardrailsGraphState,
+    escalation_result: Dict[str, Any],
+    execution_stage: ExecutionStage,
+    tool_name: str,
+) -> Dict[str, Any] | Command[Any]:
+    """Process escalation response for TOOL scope guardrails.
+
+    Updates the tool call arguments (PreExecution) or tool message content (PostExecution)
+    for the specific tool matching the tool_name. For PreExecution, finds the tool call
+    with the matching name and updates only that tool call's args with the reviewed dict.
+    For PostExecution, updates the tool message content.
+
+    Args:
+        state: The current agent graph state.
+        escalation_result: The result from the escalation interrupt containing reviewed inputs/outputs.
+        execution_stage: The execution stage (PRE_EXECUTION or POST_EXECUTION).
+        tool_name: Name of the tool to update. Only the tool call matching this name will be updated.
+
+    Returns:
+        Command to update messages with reviewed tool call args or content, or empty dict if no updates needed.
+
+    Raises:
+        AgentTerminationException: If escalation response processing fails.
+    """
+    try:
+        reviewed_field = (
+            "ReviewedInputs"
+            if execution_stage == ExecutionStage.PRE_EXECUTION
+            else "ReviewedOutputs"
+        )
+
+        msgs = state.messages.copy()
+        if not msgs or reviewed_field not in escalation_result:
+            return {}
+
+        last_message = msgs[-1]
+        if execution_stage == ExecutionStage.PRE_EXECUTION:
+            if not isinstance(last_message, AIMessage):
+                return {}
+
+            # Get reviewed tool calls args from escalation result
+            reviewed_inputs_json = escalation_result[reviewed_field]
+            if not reviewed_inputs_json:
+                return {}
+
+            reviewed_tool_calls_args = json.loads(reviewed_inputs_json)
+            if not isinstance(reviewed_tool_calls_args, dict):
+                return {}
+
+            # Find and update only the tool call with matching name
+            if last_message.tool_calls:
+                tool_calls = list(last_message.tool_calls)
+                for tool_call in tool_calls:
+                    call_name = (
+                        tool_call.get("name")
+                        if isinstance(tool_call, dict)
+                        else getattr(tool_call, "name", None)
+                    )
+                    if call_name == tool_name:
+                        # Update args for the matching tool call
+                        if isinstance(reviewed_tool_calls_args, dict):
+                            if isinstance(tool_call, dict):
+                                tool_call["args"] = reviewed_tool_calls_args
+                            else:
+                                tool_call.args = reviewed_tool_calls_args
+                        break
+                last_message.tool_calls = tool_calls
+        else:
+            if not isinstance(last_message, ToolMessage):
+                return {}
+
+            # PostExecution: update tool message content
+            reviewed_outputs_json = escalation_result[reviewed_field]
+            if reviewed_outputs_json:
+                last_message.content = reviewed_outputs_json
+
+        return Command(update={"messages": msgs})
     except Exception as e:
         raise AgentTerminationException(
             code=UiPathErrorCode.EXECUTION_ERROR,
@@ -204,35 +329,60 @@ def _extract_escalation_content(
     state: AgentGuardrailsGraphState,
     scope: GuardrailScope,
     execution_stage: ExecutionStage,
+    guarded_node_name: str,
 ) -> str | list[str | Dict[str, Any]]:
     """Extract escalation content from state based on guardrail scope and execution stage.
 
     Args:
         state: The current agent graph state.
         scope: The guardrail scope (LLM/AGENT/TOOL).
-        execution_stage: The execution stage enum.
+        execution_stage: The execution stage (PRE_EXECUTION or POST_EXECUTION).
 
     Returns:
-        For non-LLM scope: Empty string.
-        For LLM PreExecution: JSON string with message content.
-        For LLM PostExecution: JSON array with tool call content and message content.
-    """
-    if scope != GuardrailScope.LLM:
-        return ""
+        str or list[str | Dict[str, Any]]: For LLM scope, returns JSON string or list with message/tool call content.
+        For AGENT scope, returns empty string. For TOOL scope, returns JSON string or list with tool-specific content.
 
+    Raises:
+        AgentTerminationException: If no messages are found in state.
+    """
     if not state.messages:
         raise AgentTerminationException(
             code=UiPathErrorCode.EXECUTION_ERROR,
             title="Invalid state message",
-            detail="No messages in state",
+            detail="No message found into agent state",
         )
 
+    match scope:
+        case GuardrailScope.LLM:
+            return _extract_llm_escalation_content(state, execution_stage)
+        case GuardrailScope.AGENT:
+            return _extract_agent_escalation_content(state, execution_stage)
+        case GuardrailScope.TOOL:
+            return _extract_tool_escalation_content(
+                state, execution_stage, guarded_node_name
+            )
+
+
+def _extract_llm_escalation_content(
+    state: AgentGuardrailsGraphState, execution_stage: ExecutionStage
+) -> str | list[str | Dict[str, Any]]:
+    """Extract escalation content for LLM scope guardrails.
+
+    Args:
+        state: The current agent graph state.
+        execution_stage: The execution stage (PRE_EXECUTION or POST_EXECUTION).
+
+    Returns:
+        str or list[str | Dict[str, Any]]: For PreExecution, returns JSON string with message content or empty string.
+        For PostExecution, returns JSON string (array) with tool call content and message content.
+        Returns empty string if no content found.
+    """
     last_message = state.messages[-1]
     if execution_stage == ExecutionStage.PRE_EXECUTION:
         if isinstance(last_message, ToolMessage):
             return last_message.content
 
-        content = _message_text(last_message)
+        content = get_message_content(last_message)
         return json.dumps(content) if content else ""
 
     # For AI messages, process tool calls if present
@@ -250,14 +400,56 @@ def _extract_escalation_content(
                 ):
                     content_list.append(json.dumps(args["content"]))
 
-        message_content = _message_text(last_message)
+        message_content = get_message_content(last_message)
         if message_content:
             content_list.append(message_content)
 
         return json.dumps(content_list)
 
     # Fallback for other message types
-    return _message_text(last_message)
+    return get_message_content(last_message)
+
+
+def _extract_agent_escalation_content(
+    state: AgentGuardrailsGraphState, execution_stage: ExecutionStage
+) -> str | list[str | Dict[str, Any]]:
+    """Extract escalation content for AGENT scope guardrails.
+
+    Args:
+        state: The current agent graph state.
+        execution_stage: The execution stage (PRE_EXECUTION or POST_EXECUTION).
+
+    Returns:
+        str: Empty string (AGENT scope guardrails do not extract escalation content).
+    """
+    return ""
+
+
+def _extract_tool_escalation_content(
+    state: AgentGuardrailsGraphState, execution_stage: ExecutionStage, tool_name: str
+) -> str | list[str | Dict[str, Any]]:
+    """Extract escalation content for TOOL scope guardrails.
+
+    Args:
+        state: The current agent graph state.
+        execution_stage: The execution stage (PRE_EXECUTION or POST_EXECUTION).
+        tool_name: Optional tool name to filter tool calls. If provided, only extracts args for matching tool.
+
+    Returns:
+        str or list[str | Dict[str, Any]]: For PreExecution, returns JSON string with tool call arguments
+        for the specified tool name, or empty string if not found. For PostExecution, returns string with
+        tool message content, or empty string if message type doesn't match.
+    """
+    last_message = state.messages[-1]
+    if execution_stage == ExecutionStage.PRE_EXECUTION:
+        args = _extract_tool_args_from_message(last_message, tool_name)
+        if args:
+            return json.dumps(args)
+        return ""
+    else:
+        if not isinstance(last_message, ToolMessage):
+            return ""
+        return last_message.content
 
 
 def _execution_stage_to_escalation_field(
@@ -272,3 +464,19 @@ def _execution_stage_to_escalation_field(
         "Inputs" for PRE_EXECUTION, "Outputs" for POST_EXECUTION.
     """
     return "Inputs" if execution_stage == ExecutionStage.PRE_EXECUTION else "Outputs"
+
+
+def _execution_stage_to_string(
+    execution_stage: ExecutionStage,
+) -> Literal["PreExecution", "PostExecution"]:
+    """Convert ExecutionStage enum to string literal.
+
+    Args:
+        execution_stage: The execution stage enum.
+
+    Returns:
+        "PreExecution" for PRE_EXECUTION, "PostExecution" for POST_EXECUTION.
+    """
+    if execution_stage == ExecutionStage.PRE_EXECUTION:
+        return "PreExecution"
+    return "PostExecution"

uipath_langchain/agent/guardrails/actions/filter_action.py

@@ -0,0 +1,55 @@
+import re
+from typing import Any
+
+from uipath.platform.guardrails import BaseGuardrail, GuardrailScope
+from uipath.runtime.errors import UiPathErrorCategory, UiPathErrorCode
+
+from uipath_langchain.agent.guardrails.types import ExecutionStage
+
+from ...exceptions import AgentTerminationException
+from ...react.types import AgentGuardrailsGraphState
+from .base_action import GuardrailAction, GuardrailActionNode
+
+
+class FilterAction(GuardrailAction):
+    """Action that filters inputs/outputs on guardrail failure.
+
+    For now, filtering is only supported for non-AGENT and non-LLM scopes.
+    If invoked for ``GuardrailScope.AGENT`` or ``GuardrailScope.LLM``, this action
+    raises an exception to indicate the operation is not supported yet.
+    """
+
+    def action_node(
+        self,
+        *,
+        guardrail: BaseGuardrail,
+        scope: GuardrailScope,
+        execution_stage: ExecutionStage,
+        guarded_component_name: str,
+    ) -> GuardrailActionNode:
+        """Create a guardrail action node that performs filtering.
+
+        Args:
+            guardrail: The guardrail responsible for the validation.
+            scope: The scope in which the guardrail applies.
+            execution_stage: Whether this runs before or after execution.
+            guarded_component_name: Name of the guarded component.
+
+        Returns:
+            A tuple containing the node name and the async node callable.
+        """
+        raw_node_name = f"{scope.name}_{execution_stage.name}_{guardrail.name}_filter"
+        node_name = re.sub(r"\W+", "_", raw_node_name.lower()).strip("_")
+
+        async def _node(_state: AgentGuardrailsGraphState) -> dict[str, Any]:
+            if scope in (GuardrailScope.AGENT, GuardrailScope.LLM):
+                raise AgentTerminationException(
+                    code=UiPathErrorCode.EXECUTION_ERROR,
+                    title="Guardrail filter action not supported",
+                    detail=f"FilterAction is not supported for scope [{scope.name}] at this time.",
+                    category=UiPathErrorCategory.USER,
+                )
+            # No-op for other scopes for now.
+            return {}
+
+        return node_name, _node

uipath_langchain/agent/guardrails/actions/log_action.py

@@ -6,7 +6,7 @@ from uipath.platform.guardrails import BaseGuardrail, GuardrailScope
 
 from uipath_langchain.agent.guardrails.types import ExecutionStage
 
-from ..types import AgentGuardrailsGraphState
+from ...react.types import AgentGuardrailsGraphState
 from .base_action import GuardrailAction, GuardrailActionNode
 
 logger = logging.getLogger(__name__)
@@ -31,6 +31,7 @@ class LogAction(GuardrailAction):
         guardrail: BaseGuardrail,
         scope: GuardrailScope,
         execution_stage: ExecutionStage,
+        guarded_component_name: str,
     ) -> GuardrailActionNode:
         """Create a guardrail action node that logs validation failures.