langchain 0.3.27__py3-none-any.whl → 1.0.0__py3-none-any.whl

langchain/agents/middleware/tool_retry.py

@@ -0,0 +1,384 @@
+"""Tool retry middleware for agents."""
+
+from __future__ import annotations
+
+import asyncio
+import random
+import time
+from typing import TYPE_CHECKING, Literal
+
+from langchain_core.messages import ToolMessage
+
+from langchain.agents.middleware.types import AgentMiddleware
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from langgraph.types import Command
+
+    from langchain.tools import BaseTool
+    from langchain.tools.tool_node import ToolCallRequest
+
+
+class ToolRetryMiddleware(AgentMiddleware):
+    """Middleware that automatically retries failed tool calls with configurable backoff.
+
+    Supports retrying on specific exceptions and exponential backoff.
+
+    Examples:
+        Basic usage with default settings (2 retries, exponential backoff):
+        ```python
+        from langchain.agents import create_agent
+        from langchain.agents.middleware import ToolRetryMiddleware
+
+        agent = create_agent(model, tools=[search_tool], middleware=[ToolRetryMiddleware()])
+        ```
+
+        Retry specific exceptions only:
+        ```python
+        from requests.exceptions import RequestException, Timeout
+
+        retry = ToolRetryMiddleware(
+            max_retries=4,
+            retry_on=(RequestException, Timeout),
+            backoff_factor=1.5,
+        )
+        ```
+
+        Custom exception filtering:
+        ```python
+        from requests.exceptions import HTTPError
+
+
+        def should_retry(exc: Exception) -> bool:
+            # Only retry on 5xx errors
+            if isinstance(exc, HTTPError):
+                return 500 <= exc.status_code < 600
+            return False
+
+
+        retry = ToolRetryMiddleware(
+            max_retries=3,
+            retry_on=should_retry,
+        )
+        ```
+
+        Apply to specific tools with custom error handling:
+        ```python
+        def format_error(exc: Exception) -> str:
+            return "Database temporarily unavailable. Please try again later."
+
+
+        retry = ToolRetryMiddleware(
+            max_retries=4,
+            tools=["search_database"],
+            on_failure=format_error,
+        )
+        ```
+
+        Apply to specific tools using BaseTool instances:
+        ```python
+        from langchain_core.tools import tool
+
+
+        @tool
+        def search_database(query: str) -> str:
+            '''Search the database.'''
+            return results
+
+
+        retry = ToolRetryMiddleware(
+            max_retries=4,
+            tools=[search_database],  # Pass BaseTool instance
+        )
+        ```
+
+        Constant backoff (no exponential growth):
+        ```python
+        retry = ToolRetryMiddleware(
+            max_retries=5,
+            backoff_factor=0.0,  # No exponential growth
+            initial_delay=2.0,  # Always wait 2 seconds
+        )
+        ```
+
+        Raise exception on failure:
+        ```python
+        retry = ToolRetryMiddleware(
+            max_retries=2,
+            on_failure="raise",  # Re-raise exception instead of returning message
+        )
+        ```
+    """
+
+    def __init__(
+        self,
+        *,
+        max_retries: int = 2,
+        tools: list[BaseTool | str] | None = None,
+        retry_on: tuple[type[Exception], ...] | Callable[[Exception], bool] = (Exception,),
+        on_failure: (
+            Literal["raise", "return_message"] | Callable[[Exception], str]
+        ) = "return_message",
+        backoff_factor: float = 2.0,
+        initial_delay: float = 1.0,
+        max_delay: float = 60.0,
+        jitter: bool = True,
+    ) -> None:
+        """Initialize ToolRetryMiddleware.
+
+        Args:
+            max_retries: Maximum number of retry attempts after the initial call.
+                Default is 2 retries (3 total attempts). Must be >= 0.
+            tools: Optional list of tools or tool names to apply retry logic to.
+                Can be a list of `BaseTool` instances or tool name strings.
+                If `None`, applies to all tools. Default is `None`.
+            retry_on: Either a tuple of exception types to retry on, or a callable
+                that takes an exception and returns `True` if it should be retried.
+                Default is to retry on all exceptions.
+            on_failure: Behavior when all retries are exhausted. Options:
+                - `"return_message"` (default): Return a ToolMessage with error details,
+                  allowing the LLM to handle the failure and potentially recover.
+                - `"raise"`: Re-raise the exception, stopping agent execution.
+                - Custom callable: Function that takes the exception and returns a string
+                  for the ToolMessage content, allowing custom error formatting.
+            backoff_factor: Multiplier for exponential backoff. Each retry waits
+                `initial_delay * (backoff_factor ** retry_number)` seconds.
+                Set to 0.0 for constant delay. Default is 2.0.
+            initial_delay: Initial delay in seconds before first retry. Default is 1.0.
+            max_delay: Maximum delay in seconds between retries. Caps exponential
+                backoff growth. Default is 60.0.
+            jitter: Whether to add random jitter (±25%) to delay to avoid thundering herd.
+                Default is `True`.
+
+        Raises:
+            ValueError: If max_retries < 0 or delays are negative.
+        """
+        super().__init__()
+
+        # Validate parameters
+        if max_retries < 0:
+            msg = "max_retries must be >= 0"
+            raise ValueError(msg)
+        if initial_delay < 0:
+            msg = "initial_delay must be >= 0"
+            raise ValueError(msg)
+        if max_delay < 0:
+            msg = "max_delay must be >= 0"
+            raise ValueError(msg)
+        if backoff_factor < 0:
+            msg = "backoff_factor must be >= 0"
+            raise ValueError(msg)
+
+        self.max_retries = max_retries
+
+        # Extract tool names from BaseTool instances or strings
+        self._tool_filter: list[str] | None
+        if tools is not None:
+            self._tool_filter = [tool.name if not isinstance(tool, str) else tool for tool in tools]
+        else:
+            self._tool_filter = None
+
+        self.tools = []  # No additional tools registered by this middleware
+        self.retry_on = retry_on
+        self.on_failure = on_failure
+        self.backoff_factor = backoff_factor
+        self.initial_delay = initial_delay
+        self.max_delay = max_delay
+        self.jitter = jitter
+
+    def _should_retry_tool(self, tool_name: str) -> bool:
+        """Check if retry logic should apply to this tool.
+
+        Args:
+            tool_name: Name of the tool being called.
+
+        Returns:
+            `True` if retry logic should apply, `False` otherwise.
+        """
+        if self._tool_filter is None:
+            return True
+        return tool_name in self._tool_filter
+
+    def _should_retry_exception(self, exc: Exception) -> bool:
+        """Check if the exception should trigger a retry.
+
+        Args:
+            exc: The exception that occurred.
+
+        Returns:
+            `True` if the exception should be retried, `False` otherwise.
+        """
+        if callable(self.retry_on):
+            return self.retry_on(exc)
+        return isinstance(exc, self.retry_on)
+
+    def _calculate_delay(self, retry_number: int) -> float:
+        """Calculate delay for the given retry attempt.
+
+        Args:
+            retry_number: The retry attempt number (0-indexed).
+
+        Returns:
+            Delay in seconds before next retry.
+        """
+        if self.backoff_factor == 0.0:
+            delay = self.initial_delay
+        else:
+            delay = self.initial_delay * (self.backoff_factor**retry_number)
+
+        # Cap at max_delay
+        delay = min(delay, self.max_delay)
+
+        if self.jitter and delay > 0:
+            jitter_amount = delay * 0.25
+            delay = delay + random.uniform(-jitter_amount, jitter_amount)  # noqa: S311
+            # Ensure delay is not negative after jitter
+            delay = max(0, delay)
+
+        return delay
+
+    def _format_failure_message(self, tool_name: str, exc: Exception, attempts_made: int) -> str:
+        """Format the failure message when retries are exhausted.
+
+        Args:
+            tool_name: Name of the tool that failed.
+            exc: The exception that caused the failure.
+            attempts_made: Number of attempts actually made.
+
+        Returns:
+            Formatted error message string.
+        """
+        exc_type = type(exc).__name__
+        attempt_word = "attempt" if attempts_made == 1 else "attempts"
+        return f"Tool '{tool_name}' failed after {attempts_made} {attempt_word} with {exc_type}"
+
+    def _handle_failure(
+        self, tool_name: str, tool_call_id: str | None, exc: Exception, attempts_made: int
+    ) -> ToolMessage:
+        """Handle failure when all retries are exhausted.
+
+        Args:
+            tool_name: Name of the tool that failed.
+            tool_call_id: ID of the tool call (may be None).
+            exc: The exception that caused the failure.
+            attempts_made: Number of attempts actually made.
+
+        Returns:
+            ToolMessage with error details.
+
+        Raises:
+            Exception: If on_failure is "raise", re-raises the exception.
+        """
+        if self.on_failure == "raise":
+            raise exc
+
+        if callable(self.on_failure):
+            content = self.on_failure(exc)
+        else:
+            content = self._format_failure_message(tool_name, exc, attempts_made)
+
+        return ToolMessage(
+            content=content,
+            tool_call_id=tool_call_id,
+            name=tool_name,
+            status="error",
+        )
+
+    def wrap_tool_call(
+        self,
+        request: ToolCallRequest,
+        handler: Callable[[ToolCallRequest], ToolMessage | Command],
+    ) -> ToolMessage | Command:
+        """Intercept tool execution and retry on failure.
+
+        Args:
+            request: Tool call request with call dict, BaseTool, state, and runtime.
+            handler: Callable to execute the tool (can be called multiple times).
+
+        Returns:
+            ToolMessage or Command (the final result).
+        """
+        tool_name = request.tool.name if request.tool else request.tool_call["name"]
+
+        # Check if retry should apply to this tool
+        if not self._should_retry_tool(tool_name):
+            return handler(request)
+
+        tool_call_id = request.tool_call["id"]
+
+        # Initial attempt + retries
+        for attempt in range(self.max_retries + 1):
+            try:
+                return handler(request)
+            except Exception as exc:  # noqa: BLE001
+                attempts_made = attempt + 1  # attempt is 0-indexed
+
+                # Check if we should retry this exception
+                if not self._should_retry_exception(exc):
+                    # Exception is not retryable, handle failure immediately
+                    return self._handle_failure(tool_name, tool_call_id, exc, attempts_made)
+
+                # Check if we have more retries left
+                if attempt < self.max_retries:
+                    # Calculate and apply backoff delay
+                    delay = self._calculate_delay(attempt)
+                    if delay > 0:
+                        time.sleep(delay)
+                    # Continue to next retry
+                else:
+                    # No more retries, handle failure
+                    return self._handle_failure(tool_name, tool_call_id, exc, attempts_made)
+
+        # Unreachable: loop always returns via handler success or _handle_failure
+        msg = "Unexpected: retry loop completed without returning"
+        raise RuntimeError(msg)
+
+    async def awrap_tool_call(
+        self,
+        request: ToolCallRequest,
+        handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],
+    ) -> ToolMessage | Command:
+        """Intercept and control async tool execution with retry logic.
+
+        Args:
+            request: Tool call request with call dict, BaseTool, state, and runtime.
+            handler: Async callable to execute the tool and returns ToolMessage or Command.
+
+        Returns:
+            ToolMessage or Command (the final result).
+        """
+        tool_name = request.tool.name if request.tool else request.tool_call["name"]
+
+        # Check if retry should apply to this tool
+        if not self._should_retry_tool(tool_name):
+            return await handler(request)
+
+        tool_call_id = request.tool_call["id"]
+
+        # Initial attempt + retries
+        for attempt in range(self.max_retries + 1):
+            try:
+                return await handler(request)
+            except Exception as exc:  # noqa: BLE001
+                attempts_made = attempt + 1  # attempt is 0-indexed
+
+                # Check if we should retry this exception
+                if not self._should_retry_exception(exc):
+                    # Exception is not retryable, handle failure immediately
+                    return self._handle_failure(tool_name, tool_call_id, exc, attempts_made)
+
+                # Check if we have more retries left
+                if attempt < self.max_retries:
+                    # Calculate and apply backoff delay
+                    delay = self._calculate_delay(attempt)
+                    if delay > 0:
+                        await asyncio.sleep(delay)
+                    # Continue to next retry
+                else:
+                    # No more retries, handle failure
+                    return self._handle_failure(tool_name, tool_call_id, exc, attempts_made)
+
+        # Unreachable: loop always returns via handler success or _handle_failure
+        msg = "Unexpected: retry loop completed without returning"
+        raise RuntimeError(msg)

langchain/agents/middleware/tool_selection.py

@@ -0,0 +1,310 @@
+"""LLM-based tool selector middleware."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Annotated, Literal, Union
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from langchain.tools import BaseTool
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import HumanMessage
+from pydantic import Field, TypeAdapter
+from typing_extensions import TypedDict
+
+from langchain.agents.middleware.types import (
+    AgentMiddleware,
+    ModelCallResult,
+    ModelRequest,
+    ModelResponse,
+)
+from langchain.chat_models.base import init_chat_model
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_SYSTEM_PROMPT = (
+    "Your goal is to select the most relevant tools for answering the user's query."
+)
+
+
+@dataclass
+class _SelectionRequest:
+    """Prepared inputs for tool selection."""
+
+    available_tools: list[BaseTool]
+    system_message: str
+    last_user_message: HumanMessage
+    model: BaseChatModel
+    valid_tool_names: list[str]
+
+
+def _create_tool_selection_response(tools: list[BaseTool]) -> TypeAdapter:
+    """Create a structured output schema for tool selection.
+
+    Args:
+        tools: Available tools to include in the schema.
+
+    Returns:
+        TypeAdapter for a schema where each tool name is a Literal with its description.
+    """
+    if not tools:
+        msg = "Invalid usage: tools must be non-empty"
+        raise AssertionError(msg)
+
+    # Create a Union of Annotated Literal types for each tool name with description
+    # Example: Union[Annotated[Literal["tool1"], Field(description="...")], ...] noqa: ERA001
+    literals = [
+        Annotated[Literal[tool.name], Field(description=tool.description)] for tool in tools
+    ]
+    selected_tool_type = Union[tuple(literals)]  # type: ignore[valid-type]  # noqa: UP007
+
+    description = "Tools to use. Place the most relevant tools first."
+
+    class ToolSelectionResponse(TypedDict):
+        """Use to select relevant tools."""
+
+        tools: Annotated[list[selected_tool_type], Field(description=description)]  # type: ignore[valid-type]
+
+    return TypeAdapter(ToolSelectionResponse)
+
+
+def _render_tool_list(tools: list[BaseTool]) -> str:
+    """Format tools as markdown list.
+
+    Args:
+        tools: Tools to format.
+
+    Returns:
+        Markdown string with each tool on a new line.
+    """
+    return "\n".join(f"- {tool.name}: {tool.description}" for tool in tools)
+
+
+class LLMToolSelectorMiddleware(AgentMiddleware):
+    """Uses an LLM to select relevant tools before calling the main model.
+
+    When an agent has many tools available, this middleware filters them down
+    to only the most relevant ones for the user's query. This reduces token usage
+    and helps the main model focus on the right tools.
+
+    Examples:
+        Limit to 3 tools:
+        ```python
+        from langchain.agents.middleware import LLMToolSelectorMiddleware
+
+        middleware = LLMToolSelectorMiddleware(max_tools=3)
+
+        agent = create_agent(
+            model="openai:gpt-4o",
+            tools=[tool1, tool2, tool3, tool4, tool5],
+            middleware=[middleware],
+        )
+        ```
+
+        Use a smaller model for selection:
+        ```python
+        middleware = LLMToolSelectorMiddleware(model="openai:gpt-4o-mini", max_tools=2)
+        ```
+    """
+
+    def __init__(
+        self,
+        *,
+        model: str | BaseChatModel | None = None,
+        system_prompt: str = DEFAULT_SYSTEM_PROMPT,
+        max_tools: int | None = None,
+        always_include: list[str] | None = None,
+    ) -> None:
+        """Initialize the tool selector.
+
+        Args:
+            model: Model to use for selection. If not provided, uses the agent's main model.
+                Can be a model identifier string or BaseChatModel instance.
+            system_prompt: Instructions for the selection model.
+            max_tools: Maximum number of tools to select. If the model selects more,
+                only the first max_tools will be used. No limit if not specified.
+            always_include: Tool names to always include regardless of selection.
+                These do not count against the max_tools limit.
+        """
+        super().__init__()
+        self.system_prompt = system_prompt
+        self.max_tools = max_tools
+        self.always_include = always_include or []
+
+        if isinstance(model, (BaseChatModel, type(None))):
+            self.model: BaseChatModel | None = model
+        else:
+            self.model = init_chat_model(model)
+
+    def _prepare_selection_request(self, request: ModelRequest) -> _SelectionRequest | None:
+        """Prepare inputs for tool selection.
+
+        Returns:
+            SelectionRequest with prepared inputs, or None if no selection is needed.
+        """
+        # If no tools available, return None
+        if not request.tools or len(request.tools) == 0:
+            return None
+
+        # Filter to only BaseTool instances (exclude provider-specific tool dicts)
+        base_tools = [tool for tool in request.tools if not isinstance(tool, dict)]
+
+        # Validate that always_include tools exist
+        if self.always_include:
+            available_tool_names = {tool.name for tool in base_tools}
+            missing_tools = [
+                name for name in self.always_include if name not in available_tool_names
+            ]
+            if missing_tools:
+                msg = (
+                    f"Tools in always_include not found in request: {missing_tools}. "
+                    f"Available tools: {sorted(available_tool_names)}"
+                )
+                raise ValueError(msg)
+
+        # Separate tools that are always included from those available for selection
+        available_tools = [tool for tool in base_tools if tool.name not in self.always_include]
+
+        # If no tools available for selection, return None
+        if not available_tools:
+            return None
+
+        system_message = self.system_prompt
+        # If there's a max_tools limit, append instructions to the system prompt
+        if self.max_tools is not None:
+            system_message += (
+                f"\nIMPORTANT: List the tool names in order of relevance, "
+                f"with the most relevant first. "
+                f"If you exceed the maximum number of tools, "
+                f"only the first {self.max_tools} will be used."
+            )
+
+        # Get the last user message from the conversation history
+        last_user_message: HumanMessage
+        for message in reversed(request.messages):
+            if isinstance(message, HumanMessage):
+                last_user_message = message
+                break
+        else:
+            msg = "No user message found in request messages"
+            raise AssertionError(msg)
+
+        model = self.model or request.model
+        valid_tool_names = [tool.name for tool in available_tools]
+
+        return _SelectionRequest(
+            available_tools=available_tools,
+            system_message=system_message,
+            last_user_message=last_user_message,
+            model=model,
+            valid_tool_names=valid_tool_names,
+        )
+
+    def _process_selection_response(
+        self,
+        response: dict,
+        available_tools: list[BaseTool],
+        valid_tool_names: list[str],
+        request: ModelRequest,
+    ) -> ModelRequest:
+        """Process the selection response and return filtered ModelRequest."""
+        selected_tool_names: list[str] = []
+        invalid_tool_selections = []
+
+        for tool_name in response["tools"]:
+            if tool_name not in valid_tool_names:
+                invalid_tool_selections.append(tool_name)
+                continue
+
+            # Only add if not already selected and within max_tools limit
+            if tool_name not in selected_tool_names and (
+                self.max_tools is None or len(selected_tool_names) < self.max_tools
+            ):
+                selected_tool_names.append(tool_name)
+
+        if invalid_tool_selections:
+            msg = f"Model selected invalid tools: {invalid_tool_selections}"
+            raise ValueError(msg)
+
+        # Filter tools based on selection and append always-included tools
+        selected_tools: list[BaseTool] = [
+            tool for tool in available_tools if tool.name in selected_tool_names
+        ]
+        always_included_tools: list[BaseTool] = [
+            tool
+            for tool in request.tools
+            if not isinstance(tool, dict) and tool.name in self.always_include
+        ]
+        selected_tools.extend(always_included_tools)
+
+        # Also preserve any provider-specific tool dicts from the original request
+        provider_tools = [tool for tool in request.tools if isinstance(tool, dict)]
+
+        request.tools = [*selected_tools, *provider_tools]
+        return request
+
+    def wrap_model_call(
+        self,
+        request: ModelRequest,
+        handler: Callable[[ModelRequest], ModelResponse],
+    ) -> ModelCallResult:
+        """Filter tools based on LLM selection before invoking the model via handler."""
+        selection_request = self._prepare_selection_request(request)
+        if selection_request is None:
+            return handler(request)
+
+        # Create dynamic response model with Literal enum of available tool names
+        type_adapter = _create_tool_selection_response(selection_request.available_tools)
+        schema = type_adapter.json_schema()
+        structured_model = selection_request.model.with_structured_output(schema)
+
+        response = structured_model.invoke(
+            [
+                {"role": "system", "content": selection_request.system_message},
+                selection_request.last_user_message,
+            ]
+        )
+
+        # Response should be a dict since we're passing a schema (not a Pydantic model class)
+        if not isinstance(response, dict):
+            msg = f"Expected dict response, got {type(response)}"
+            raise AssertionError(msg)
+        modified_request = self._process_selection_response(
+            response, selection_request.available_tools, selection_request.valid_tool_names, request
+        )
+        return handler(modified_request)
+
+    async def awrap_model_call(
+        self,
+        request: ModelRequest,
+        handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
+    ) -> ModelCallResult:
+        """Filter tools based on LLM selection before invoking the model via handler."""
+        selection_request = self._prepare_selection_request(request)
+        if selection_request is None:
+            return await handler(request)
+
+        # Create dynamic response model with Literal enum of available tool names
+        type_adapter = _create_tool_selection_response(selection_request.available_tools)
+        schema = type_adapter.json_schema()
+        structured_model = selection_request.model.with_structured_output(schema)
+
+        response = await structured_model.ainvoke(
+            [
+                {"role": "system", "content": selection_request.system_message},
+                selection_request.last_user_message,
+            ]
+        )
+
+        # Response should be a dict since we're passing a schema (not a Pydantic model class)
+        if not isinstance(response, dict):
+            msg = f"Expected dict response, got {type(response)}"
+            raise AssertionError(msg)
+        modified_request = self._process_selection_response(
+            response, selection_request.available_tools, selection_request.valid_tool_names, request
+        )
+        return await handler(modified_request)