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

uipath_langchain/agent/react/router.py

@@ -6,9 +6,8 @@ from langchain_core.messages import AIMessage, AnyMessage, ToolCall
 from uipath.agent.react import END_EXECUTION_TOOL, RAISE_ERROR_TOOL
 
 from ..exceptions import AgentNodeRoutingException
-from .constants import MAX_SUCCESSIVE_COMPLETIONS
 from .types import AgentGraphNode, AgentGraphState
-from .utils import count_successive_completions
+from .utils import count_consecutive_thinking_messages
 
 FLOW_CONTROL_TOOLS = [END_EXECUTION_TOOL.name, RAISE_ERROR_TOOL.name]
 
@@ -48,50 +47,62 @@ def __validate_last_message_is_AI(messages: list[AnyMessage]) -> AIMessage:
     return last_message
 
 
-def route_agent(
-    state: AgentGraphState,
-) -> list[str] | Literal[AgentGraphNode.AGENT, AgentGraphNode.TERMINATE]:
-    """Route after agent: handles all routing logic including control flow detection.
+def create_route_agent(thinking_messages_limit: int = 0):
+    """Create a routing function configured with thinking_messages_limit.
 
-    Routing logic:
-    1. If multiple tool calls exist, filter out control flow tools (EndExecution, RaiseError)
-    2. If control flow tool(s) remain, route to TERMINATE
-    3. If regular tool calls remain, route to specific tool nodes (return list of tool names)
-    4. If no tool calls, handle successive completions
+    Args:
+        thinking_messages_limit: Max consecutive thinking messages before error
 
     Returns:
-        - list[str]: Tool node names for parallel execution
-        - AgentGraphNode.AGENT: For successive completions
-        - AgentGraphNode.TERMINATE: For control flow termination
-
-    Raises:
-        AgentNodeRoutingException: When encountering unexpected state (empty messages, non-AIMessage, or excessive completions)
+        Routing function for LangGraph conditional edges
     """
-    messages = state.messages
-    last_message = __validate_last_message_is_AI(messages)
 
-    tool_calls = list(last_message.tool_calls) if last_message.tool_calls else []
-    tool_calls = __filter_control_flow_tool_calls(tool_calls)
+    def route_agent(
+        state: AgentGraphState,
+    ) -> list[str] | Literal[AgentGraphNode.AGENT, AgentGraphNode.TERMINATE]:
+        """Route after agent: handles all routing logic including control flow detection.
+
+        Routing logic:
+        1. If multiple tool calls exist, filter out control flow tools (EndExecution, RaiseError)
+        2. If control flow tool(s) remain, route to TERMINATE
+        3. If regular tool calls remain, route to specific tool nodes (return list of tool names)
+        4. If no tool calls, handle consecutive completions
+
+        Returns:
+            - list[str]: Tool node names for parallel execution
+            - AgentGraphNode.AGENT: For consecutive completions
+            - AgentGraphNode.TERMINATE: For control flow termination
+
+        Raises:
+            AgentNodeRoutingException: When encountering unexpected state (empty messages, non-AIMessage, or excessive completions)
+        """
+        messages = state.messages
+        last_message = __validate_last_message_is_AI(messages)
 
-    if tool_calls and __has_control_flow_tool(tool_calls):
-        return AgentGraphNode.TERMINATE
+        tool_calls = list(last_message.tool_calls) if last_message.tool_calls else []
+        tool_calls = __filter_control_flow_tool_calls(tool_calls)
 
-    if tool_calls:
-        return [tc["name"] for tc in tool_calls]
+        if tool_calls and __has_control_flow_tool(tool_calls):
+            return AgentGraphNode.TERMINATE
 
-    successive_completions = count_successive_completions(messages)
+        if tool_calls:
+            return [tc["name"] for tc in tool_calls]
+
+        consecutive_thinking_messages = count_consecutive_thinking_messages(messages)
+
+        if consecutive_thinking_messages > thinking_messages_limit:
+            raise AgentNodeRoutingException(
+                f"Agent exceeded consecutive completions limit without producing tool calls "
+                f"(completions: {consecutive_thinking_messages}, max: {thinking_messages_limit}). "
+                f"This should not happen as tool_choice='required' is enforced at the limit."
+            )
+
+        if last_message.content:
+            return AgentGraphNode.AGENT
 
-    if successive_completions > MAX_SUCCESSIVE_COMPLETIONS:
         raise AgentNodeRoutingException(
-            f"Agent exceeded successive completions limit without producing tool calls "
-            f"(completions: {successive_completions}, max: {MAX_SUCCESSIVE_COMPLETIONS}). "
-            f"This should not happen as tool_choice='required' is enforced at the limit."
+            f"Agent produced empty response without tool calls "
+            f"(completions: {consecutive_thinking_messages}, has_content: False)"
         )
 
-    if last_message.content:
-        return AgentGraphNode.AGENT
-
-    raise AgentNodeRoutingException(
-        f"Agent produced empty response without tool calls "
-        f"(completions: {successive_completions}, has_content: False)"
-    )
+    return route_agent

uipath_langchain/agent/react/types.py

@@ -1,5 +1,5 @@
 from enum import StrEnum
-from typing import Annotated
+from typing import Annotated, Any, Optional
 
 from langchain_core.messages import AnyMessage
 from langgraph.graph.message import add_messages
@@ -25,15 +25,29 @@ class AgentGraphState(BaseModel):
     termination: AgentTermination | None = None
 
 
+class AgentGuardrailsGraphState(AgentGraphState):
+    """Agent Guardrails Graph state for guardrail subgraph."""
+
+    guardrail_validation_result: Optional[str] = None
+    agent_result: Optional[dict[str, Any]] = None
+
+
 class AgentGraphNode(StrEnum):
     INIT = "init"
+    GUARDED_INIT = "guarded-init"
     AGENT = "agent"
     LLM = "llm"
     TOOLS = "tools"
     TERMINATE = "terminate"
+    GUARDED_TERMINATE = "guarded-terminate"
 
 
 class AgentGraphConfig(BaseModel):
     recursion_limit: int = Field(
         default=50, ge=1, description="Maximum recursion limit for the agent graph"
     )
+    thinking_messages_limit: int = Field(
+        default=0,
+        ge=0,
+        description="Max consecutive thinking messages before enforcing tool usage. 0 = force tools every time.",
+    )

uipath_langchain/agent/react/utils.py

@@ -28,7 +28,7 @@ def resolve_output_model(
     return END_EXECUTION_TOOL.args_schema
 
 
-def count_successive_completions(messages: Sequence[BaseMessage]) -> int:
+def count_consecutive_thinking_messages(messages: Sequence[BaseMessage]) -> int:
     """Count consecutive AIMessages without tool calls at end of message history."""
     if not messages:
         return 0

uipath_langchain/agent/tools/__init__.py

@@ -2,6 +2,7 @@
 
 from .context_tool import create_context_tool
 from .integration_tool import create_integration_tool
+from .mcp_tool import create_mcp_tools
 from .process_tool import create_process_tool
 from .tool_factory import (
     create_tools_from_resources,
@@ -14,4 +15,5 @@ __all__ = [
     "create_context_tool",
     "create_process_tool",
     "create_integration_tool",
+    "create_mcp_tools",
 ]

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/chat/__init__.py

@@ -1,10 +1,14 @@
 from .mapper import UiPathChatMessagesMapper
 from .models import UiPathAzureChatOpenAI, UiPathChat
 from .openai import UiPathChatOpenAI
+from .supported_models import BedrockModels, GeminiModels, OpenAIModels
 
 __all__ = [
     "UiPathChat",
     "UiPathAzureChatOpenAI",
     "UiPathChatOpenAI",
     "UiPathChatMessagesMapper",
+    "OpenAIModels",
+    "BedrockModels",
+    "GeminiModels",
 ]

uipath_langchain/chat/bedrock.py

@@ -48,10 +48,14 @@ class AwsBedrockCompletionsPassthroughClient:
         model: str,
         token: str,
         api_flavor: str,
+        agenthub_config: Optional[str] = None,
+        byo_connection_id: Optional[str] = None,
     ):
         self.model = model
         self.token = token
         self.api_flavor = api_flavor
+        self.agenthub_config = agenthub_config
+        self.byo_connection_id = byo_connection_id
         self._vendor = "awsbedrock"
         self._url: Optional[str] = None
 
@@ -101,6 +105,10 @@ class AwsBedrockCompletionsPassthroughClient:
             "X-UiPath-Streaming-Enabled": streaming,
         }
 
+        if self.agenthub_config:
+            headers["X-UiPath-AgentHub-Config"] = self.agenthub_config
+        if self.byo_connection_id:
+            headers["X-UiPath-LlmGateway-ByoIsConnectionId"] = self.byo_connection_id
         job_key = os.getenv("UIPATH_JOB_KEY")
         process_key = os.getenv("UIPATH_PROCESS_KEY")
         if job_key:
@@ -118,6 +126,8 @@ class UiPathChatBedrockConverse(ChatBedrockConverse):
         tenant_id: Optional[str] = None,
         token: Optional[str] = None,
         model_name: str = BedrockModels.anthropic_claude_haiku_4_5,
+        agenthub_config: Optional[str] = None,
+        byo_connection_id: Optional[str] = None,
         **kwargs,
     ):
         org_id = org_id or os.getenv("UIPATH_ORGANIZATION_ID")
@@ -141,6 +151,8 @@ class UiPathChatBedrockConverse(ChatBedrockConverse):
             model=model_name,
             token=token,
             api_flavor="converse",
+            agenthub_config=agenthub_config,
+            byo_connection_id=byo_connection_id,
         )
 
         client = passthrough_client.get_client()
@@ -156,6 +168,8 @@ class UiPathChatBedrock(ChatBedrock):
         tenant_id: Optional[str] = None,
         token: Optional[str] = None,
         model_name: str = BedrockModels.anthropic_claude_haiku_4_5,
+        agenthub_config: Optional[str] = None,
+        byo_connection_id: Optional[str] = None,
         **kwargs,
     ):
         org_id = org_id or os.getenv("UIPATH_ORGANIZATION_ID")
@@ -179,6 +193,8 @@ class UiPathChatBedrock(ChatBedrock):
             model=model_name,
             token=token,
             api_flavor="invoke",
+            agenthub_config=agenthub_config,
+            byo_connection_id=byo_connection_id,
         )
 
         client = passthrough_client.get_client()

uipath_langchain/chat/openai.py

@@ -12,21 +12,41 @@ from .supported_models import OpenAIModels
 logger = logging.getLogger(__name__)
 
 
+def _rewrite_openai_url(
+    original_url: str, params: httpx.QueryParams
+) -> httpx.URL | None:
+    """Rewrite OpenAI URLs to UiPath gateway completions endpoint.
+
+    Handles three URL patterns:
+    - responses: false -> .../openai/deployments/.../chat/completions?api-version=...
+    - responses: true  -> .../openai/responses?api-version=...
+    - responses API base -> .../{model}?api-version=... (no /openai/ path)
+
+    All are rewritten to .../completions
+    """
+    if "/openai/deployments/" in original_url:
+        base_url = original_url.split("/openai/deployments/")[0]
+    elif "/openai/responses" in original_url:
+        base_url = original_url.split("/openai/responses")[0]
+    else:
+        # Handle base URL case (no /openai/ path appended yet)
+        # Strip query string to get base URL
+        base_url = original_url.split("?")[0]
+
+    new_url_str = f"{base_url}/completions"
+    if params:
+        return httpx.URL(new_url_str, params=params)
+    return httpx.URL(new_url_str)
+
+
 class UiPathURLRewriteTransport(httpx.AsyncHTTPTransport):
     def __init__(self, verify: bool = True, **kwargs):
         super().__init__(verify=verify, **kwargs)
 
     async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
-        original_url = str(request.url)
-
-        if "/openai/deployments/" in original_url:
-            base_url = original_url.split("/openai/deployments/")[0]
-            query_string = request.url.params
-            new_url_str = f"{base_url}/completions"
-            if query_string:
-                request.url = httpx.URL(new_url_str, params=query_string)
-            else:
-                request.url = httpx.URL(new_url_str)
+        new_url = _rewrite_openai_url(str(request.url), request.url.params)
+        if new_url:
+            request.url = new_url
 
         return await super().handle_async_request(request)
 
@@ -36,16 +56,9 @@ class UiPathSyncURLRewriteTransport(httpx.HTTPTransport):
         super().__init__(verify=verify, **kwargs)
 
     def handle_request(self, request: httpx.Request) -> httpx.Response:
-        original_url = str(request.url)
-
-        if "/openai/deployments/" in original_url:
-            base_url = original_url.split("/openai/deployments/")[0]
-            query_string = request.url.params
-            new_url_str = f"{base_url}/completions"
-            if query_string:
-                request.url = httpx.URL(new_url_str, params=query_string)
-            else:
-                request.url = httpx.URL(new_url_str)
+        new_url = _rewrite_openai_url(str(request.url), request.url.params)
+        if new_url:
+            request.url = new_url
 
         return super().handle_request(request)
 
@@ -58,6 +71,9 @@ class UiPathChatOpenAI(AzureChatOpenAI):
         api_version: str = "2024-12-01-preview",
         org_id: Optional[str] = None,
         tenant_id: Optional[str] = None,
+        agenthub_config: Optional[str] = None,
+        extra_headers: Optional[dict[str, str]] = None,
+        byo_connection_id: Optional[str] = None,
         **kwargs,
     ):
         org_id = org_id or os.getenv("UIPATH_ORGANIZATION_ID")
@@ -81,18 +97,24 @@ class UiPathChatOpenAI(AzureChatOpenAI):
         self._vendor = "openai"
         self._model_name = model_name
         self._url: Optional[str] = None
+        self._agenthub_config = agenthub_config
+        self._byo_connection_id = byo_connection_id
+        self._extra_headers = extra_headers or {}
+
+        client_kwargs = get_httpx_client_kwargs()
+        verify = client_kwargs.get("verify", True)
 
         super().__init__(
             azure_endpoint=self._build_base_url(),
             model_name=model_name,
             default_headers=self._build_headers(token),
             http_async_client=httpx.AsyncClient(
-                transport=UiPathURLRewriteTransport(verify=True),
-                **get_httpx_client_kwargs(),
+                transport=UiPathURLRewriteTransport(verify=verify),
+                **client_kwargs,
             ),
             http_client=httpx.Client(
-                transport=UiPathSyncURLRewriteTransport(verify=True),
-                **get_httpx_client_kwargs(),
+                transport=UiPathSyncURLRewriteTransport(verify=verify),
+                **client_kwargs,
             ),
             api_key=token,
             api_version=api_version,
@@ -105,10 +127,18 @@ class UiPathChatOpenAI(AzureChatOpenAI):
             "X-UiPath-LlmGateway-ApiFlavor": "auto",
             "Authorization": f"Bearer {token}",
         }
+
+        if self._agenthub_config:
+            headers["X-UiPath-AgentHub-Config"] = self._agenthub_config
+        if self._byo_connection_id:
+            headers["X-UiPath-LlmGateway-ByoIsConnectionId"] = self._byo_connection_id
         if job_key := os.getenv("UIPATH_JOB_KEY"):
             headers["X-UiPath-JobKey"] = job_key
         if process_key := os.getenv("UIPATH_PROCESS_KEY"):
             headers["X-UiPath-ProcessKey"] = process_key
+
+        # Allow extra_headers to override defaults
+        headers.update(self._extra_headers)
         return headers
 
     @property
@@ -117,9 +147,9 @@ class UiPathChatOpenAI(AzureChatOpenAI):
         formatted_endpoint = vendor_endpoint.format(
             vendor=self._vendor,
             model=self._model_name,
-            api_version=self._openai_api_version,
         )
-        return formatted_endpoint.replace("/completions", "")
+        base_endpoint = formatted_endpoint.replace("/completions", "")
+        return f"{base_endpoint}?api-version={self._openai_api_version}"
 
     def _build_base_url(self) -> str:
         if not self._url:

uipath_langchain/chat/supported_models.py

@@ -21,14 +21,21 @@ class OpenAIModels:
     # GPT-5.1 models
     gpt_5_1_2025_11_13 = "gpt-5.1-2025-11-13"
 
+    # GPT-5.2 models
+    gpt_5_2_2025_12_11 = "gpt-5.2-2025-12-11"
+
 
 class GeminiModels:
     """Supported Google Gemini model identifiers."""
 
+    # Gemini 2 models
     gemini_2_5_pro = "gemini-2.5-pro"
     gemini_2_5_flash = "gemini-2.5-flash"
     gemini_2_0_flash_001 = "gemini-2.0-flash-001"
 
+    # Gemini 3 models
+    gemini_3_pro_preview = "gemini-3-pro-preview"
+
 
 class BedrockModels:
     """Supported AWS Bedrock model identifiers."""
@@ -38,5 +45,7 @@ class BedrockModels:
 
     # Claude 4 models
     anthropic_claude_sonnet_4 = "anthropic.claude-sonnet-4-20250514-v1:0"
+
+    # Claude 4.5 models
     anthropic_claude_sonnet_4_5 = "anthropic.claude-sonnet-4-5-20250929-v1:0"
     anthropic_claude_haiku_4_5 = "anthropic.claude-haiku-4-5-20251001-v1:0"