uipath-langchain 0.1.28__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/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
 
 

uipath_langchain/agent/guardrails/actions/escalate_action.py

@@ -4,7 +4,7 @@ import json
 import re
 from typing import Any, Dict, Literal
 
-from langchain_core.messages import AIMessage, ToolCall, ToolMessage
+from langchain_core.messages import AIMessage, ToolMessage
 from langgraph.types import Command, interrupt
 from uipath.platform.common import CreateEscalation
 from uipath.platform.guardrails import (
@@ -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
 
 
@@ -229,7 +230,7 @@ def _process_llm_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,
@@ -292,7 +293,11 @@ def _process_tool_escalation_response(
             if last_message.tool_calls:
                 tool_calls = list(last_message.tool_calls)
                 for tool_call in tool_calls:
-                    call_name = extract_tool_name(tool_call)
+                    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):
@@ -311,7 +316,7 @@ def _process_tool_escalation_response(
             if reviewed_outputs_json:
                 last_message.content = reviewed_outputs_json
 
-        return Command[Any](update={"messages": msgs})
+        return Command(update={"messages": msgs})
     except Exception as e:
         raise AgentTerminationException(
             code=UiPathErrorCode.EXECUTION_ERROR,
@@ -377,7 +382,7 @@ def _extract_llm_escalation_content(
         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
@@ -395,14 +400,14 @@ def _extract_llm_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(
@@ -437,23 +442,9 @@ def _extract_tool_escalation_content(
     """
     last_message = state.messages[-1]
     if execution_stage == ExecutionStage.PRE_EXECUTION:
-        if not isinstance(last_message, AIMessage):
-            return ""
-        if not last_message.tool_calls:
-            return ""
-
-        # Find the tool call with matching name
-        for tool_call in last_message.tool_calls:
-            call_name = extract_tool_name(tool_call)
-            if call_name == tool_name:
-                # Extract args from the matching tool call
-                args = (
-                    tool_call.get("args")
-                    if isinstance(tool_call, dict)
-                    else getattr(tool_call, "args", None)
-                )
-                if args is not None:
-                    return json.dumps(args)
+        args = _extract_tool_args_from_message(last_message, tool_name)
+        if args:
+            return json.dumps(args)
         return ""
     else:
         if not isinstance(last_message, ToolMessage):
@@ -461,14 +452,6 @@ def _extract_tool_escalation_content(
         return last_message.content
 
 
-def extract_tool_name(tool_call: ToolCall) -> Any | None:
-    return (
-        tool_call.get("name")
-        if isinstance(tool_call, dict)
-        else getattr(tool_call, "name", None)
-    )
-
-
 def _execution_stage_to_escalation_field(
     execution_stage: ExecutionStage,
 ) -> str:

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__)

uipath_langchain/agent/guardrails/guardrail_nodes.py

@@ -3,25 +3,107 @@ import logging
 import re
 from typing import Any, Callable
 
-from langchain_core.messages import AIMessage, AnyMessage, HumanMessage, SystemMessage
 from langgraph.types import Command
+from uipath.core.guardrails import (
+    DeterministicGuardrail,
+    DeterministicGuardrailsService,
+)
 from uipath.platform import UiPath
 from uipath.platform.guardrails import (
     BaseGuardrail,
+    BuiltInValidatorGuardrail,
     GuardrailScope,
 )
+from uipath.runtime.errors import UiPathErrorCode
 
 from uipath_langchain.agent.guardrails.types import ExecutionStage
+from uipath_langchain.agent.guardrails.utils import (
+    _extract_tool_input_data,
+    _extract_tool_output_data,
+    get_message_content,
+)
+from uipath_langchain.agent.react.types import AgentGuardrailsGraphState
 
-from .types import AgentGuardrailsGraphState
+from ..exceptions import AgentTerminationException
 
 logger = logging.getLogger(__name__)
 
 
-def _message_text(msg: AnyMessage) -> str:
-    if isinstance(msg, (HumanMessage, SystemMessage)):
-        return msg.content if isinstance(msg.content, str) else str(msg.content)
-    return str(getattr(msg, "content", "")) if hasattr(msg, "content") else ""
+def _evaluate_deterministic_guardrail(
+    state: AgentGuardrailsGraphState,
+    guardrail: DeterministicGuardrail,
+    execution_stage: ExecutionStage,
+    input_data_extractor: Callable[[AgentGuardrailsGraphState], dict[str, Any]],
+    output_data_extractor: Callable[[AgentGuardrailsGraphState], dict[str, Any]] | None,
+):
+    """Evaluate deterministic guardrail.
+
+    Args:
+        state: The current agent graph state.
+        guardrail: The deterministic guardrail to evaluate.
+        execution_stage: The execution stage (PRE_EXECUTION or POST_EXECUTION).
+        input_data_extractor: Function to extract input data from state.
+        output_data_extractor: Function to extract output data from state (optional).
+
+    Returns:
+        The guardrail evaluation result.
+    """
+    service = DeterministicGuardrailsService()
+    input_data = input_data_extractor(state)
+
+    if execution_stage == ExecutionStage.PRE_EXECUTION:
+        return service.evaluate_pre_deterministic_guardrail(
+            input_data=input_data, guardrail=guardrail
+        )
+    else:  # POST_EXECUTION
+        output_data = output_data_extractor(state) if output_data_extractor else {}
+        return service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+
+def _evaluate_builtin_guardrail(
+    state: AgentGuardrailsGraphState,
+    guardrail: BuiltInValidatorGuardrail,
+    payload_generator: Callable[[AgentGuardrailsGraphState], str],
+):
+    """Evaluate built-in validator guardrail.
+
+    Args:
+        state: The current agent graph state.
+        guardrail: The built-in validator guardrail to evaluate.
+        payload_generator: Function to generate payload text from state.
+
+    Returns:
+        The guardrail evaluation result.
+    """
+    text = payload_generator(state)
+    uipath = UiPath()
+    return uipath.guardrails.evaluate_guardrail(text, guardrail)
+
+
+def _create_validation_command(
+    result,
+    success_node: str,
+    failure_node: str,
+) -> Command[Any]:
+    """Create command based on validation result.
+
+    Args:
+        result: The guardrail evaluation result.
+        success_node: Node to route to on validation pass.
+        failure_node: Node to route to on validation fail.
+
+    Returns:
+        Command to update state and route to appropriate node.
+    """
+    if not result.validation_passed:
+        return Command(
+            goto=failure_node, update={"guardrail_validation_result": result.reason}
+        )
+    return Command(goto=success_node, update={"guardrail_validation_result": None})
 
 
 def _create_guardrail_node(
@@ -31,6 +113,10 @@ def _create_guardrail_node(
     payload_generator: Callable[[AgentGuardrailsGraphState], str],
     success_node: str,
     failure_node: str,
+    input_data_extractor: Callable[[AgentGuardrailsGraphState], dict[str, Any]]
+    | None = None,
+    output_data_extractor: Callable[[AgentGuardrailsGraphState], dict[str, Any]]
+    | None = None,
 ) -> tuple[str, Callable[[AgentGuardrailsGraphState], Any]]:
     """Private factory for guardrail evaluation nodes.
 
@@ -44,19 +130,41 @@ def _create_guardrail_node(
     async def node(
         state: AgentGuardrailsGraphState,
     ):
-        text = payload_generator(state)
         try:
-            uipath = UiPath()
-            result = uipath.guardrails.evaluate_guardrail(text, guardrail)
-        except Exception as exc:
-            logger.error("Failed to evaluate guardrail: %s", exc)
-            raise
+            # Route to appropriate evaluation service based on guardrail type and scope
+            if (
+                isinstance(guardrail, DeterministicGuardrail)
+                and scope == GuardrailScope.TOOL
+                and input_data_extractor is not None
+            ):
+                result = _evaluate_deterministic_guardrail(
+                    state,
+                    guardrail,
+                    execution_stage,
+                    input_data_extractor,
+                    output_data_extractor,
+                )
+            elif isinstance(guardrail, BuiltInValidatorGuardrail):
+                result = _evaluate_builtin_guardrail(
+                    state, guardrail, payload_generator
+                )
+            else:
+                raise AgentTerminationException(
+                    code=UiPathErrorCode.EXECUTION_ERROR,
+                    title="Unsupported guardrail type",
+                    detail=f"Guardrail type '{type(guardrail).__name__}' is not supported. "
+                    f"Expected DeterministicGuardrail or BuiltInValidatorGuardrail.",
+                )
+
+            return _create_validation_command(result, success_node, failure_node)
 
-        if not result.validation_passed:
-            return Command(
-                goto=failure_node, update={"guardrail_validation_result": result.reason}
+        except Exception as exc:
+            logger.error(
+                "Failed to evaluate guardrail '%s': %s",
+                guardrail.name,
+                exc,
             )
-        return Command(goto=success_node, update={"guardrail_validation_result": None})
+            raise
 
     return node_name, node
 
@@ -70,7 +178,7 @@ def create_llm_guardrail_node(
     def _payload_generator(state: AgentGuardrailsGraphState) -> str:
         if not state.messages:
             return ""
-        return _message_text(state.messages[-1])
+        return get_message_content(state.messages[-1])
 
     return _create_guardrail_node(
         guardrail,
@@ -82,17 +190,35 @@ def create_llm_guardrail_node(
     )
 
 
-def create_agent_guardrail_node(
+def create_agent_init_guardrail_node(
     guardrail: BaseGuardrail,
     execution_stage: ExecutionStage,
     success_node: str,
     failure_node: str,
 ) -> tuple[str, Callable[[AgentGuardrailsGraphState], Any]]:
-    # To be implemented in future PR
     def _payload_generator(state: AgentGuardrailsGraphState) -> str:
         if not state.messages:
             return ""
-        return _message_text(state.messages[-1])
+        return get_message_content(state.messages[-1])
+
+    return _create_guardrail_node(
+        guardrail,
+        GuardrailScope.AGENT,
+        execution_stage,
+        _payload_generator,
+        success_node,
+        failure_node,
+    )
+
+
+def create_agent_terminate_guardrail_node(
+    guardrail: BaseGuardrail,
+    execution_stage: ExecutionStage,
+    success_node: str,
+    failure_node: str,
+) -> tuple[str, Callable[[AgentGuardrailsGraphState], Any]]:
+    def _payload_generator(state: AgentGuardrailsGraphState) -> str:
+        return str(state.agent_result)
 
     return _create_guardrail_node(
         guardrail,
@@ -137,31 +263,19 @@ def create_tool_guardrail_node(
             return ""
 
         if execution_stage == ExecutionStage.PRE_EXECUTION:
-            if not isinstance(state.messages[-1], AIMessage):
-                return ""
-            message = state.messages[-1]
-
-            if not message.tool_calls:
-                return ""
-
-            # Find the first tool call with matching name
-            for tool_call in message.tool_calls:
-                call_name = (
-                    tool_call.get("name")
-                    if isinstance(tool_call, dict)
-                    else getattr(tool_call, "name", None)
-                )
-                if call_name == tool_name:
-                    # Extract args from the tool call
-                    args = (
-                        tool_call.get("args")
-                        if isinstance(tool_call, dict)
-                        else getattr(tool_call, "args", None)
-                    )
-                    if args is not None:
-                        return json.dumps(args)
-
-        return _message_text(state.messages[-1])
+            # Extract tool args as dict and convert to JSON string
+            args_dict = _extract_tool_input_data(state, tool_name, execution_stage)
+            if args_dict:
+                return json.dumps(args_dict)
+
+        return get_message_content(state.messages[-1])
+
+    # Create closures for input/output data extraction (for deterministic guardrails)
+    def _input_data_extractor(state: AgentGuardrailsGraphState) -> dict[str, Any]:
+        return _extract_tool_input_data(state, tool_name, execution_stage)
+
+    def _output_data_extractor(state: AgentGuardrailsGraphState) -> dict[str, Any]:
+        return _extract_tool_output_data(state)
 
     return _create_guardrail_node(
         guardrail,
@@ -170,4 +284,6 @@ def create_tool_guardrail_node(
         _payload_generator,
         success_node,
         failure_node,
+        _input_data_extractor,
+        _output_data_extractor,
     )