i5SrSSKJr SSKrSSKrSSKrSSKJrJr SSK J r SSK J r \(aSSK JrJr SSKJr SS K Jr SS KJr "S S \ 5rg) z!Tool retry middleware for agents.) annotationsN) TYPE_CHECKINGLiteral) ToolMessage)AgentMiddleware) AwaitableCallable)Command)ToolCallRequest)BaseToolc ^\rSrSrSrSS\4SSSSS S .SU4S jjjrSS jrSS jrSSjr SSjr SSjr SSjr SSjr SrU=r$)ToolRetryMiddlewareaMiddleware 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 ) ``` Nreturn_messageg@g?gN@T) max_retriestoolsretry_on on_failurebackoff_factor initial_delay max_delayjitterc>[T U]5 US:a Sn [U 5eUS:a Sn [U 5eUS:a Sn [U 5eUS:a Sn [U 5eXlU Ub:UV s/sH&n [ U [ 5(d U R OU PM( sn UlOSUl/UlX0l X@l XPl X`l Xpl Xlgs sn f)u8Initialize 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. rzmax_retries must be >= 0zinitial_delay must be >= 0zmax_delay must be >= 0zbackoff_factor must be >= 0N)super__init__ ValueErrorr isinstancestrname _tool_filterrrrrrrr) selfrrrrrrrrmsgtool __class__s `/home/james-whalen/.local/lib/python3.13/site-packages/langchain/agents/middleware/tool_retry.pyrToolRetryMiddleware.__init__rsV  ?,CS/ ! 1 .CS/ ! q=*CS/ ! A /CS/ !&  ^c d^cVZ*T32G2GT!Q^c dD  $D   $,*" !es+-Cc:URcgXR;$)zCheck 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. T)r!)r" tool_names r&_should_retry_tool&ToolRetryMiddleware._should_retry_tools"    $----c[UR5(aURU5$[XR5$)zCheck if the exception should trigger a retry. Args: exc: The exception that occurred. Returns: `True` if the exception should be retried, `False` otherwise. )callablerr)r"excs r&_should_retry_exception+ToolRetryMiddleware._should_retry_exceptions1 DMM " "==% %#}}--r,c(URS:Xa URnOURURU--n[X R5nUR(a2US:a,US-nU[ R "U*U5-n[SU5nU$)zCalculate delay for the given retry attempt. Args: retry_number: The retry attempt number (0-indexed). Returns: Delay in seconds before next retry. grg?)rrminrrrandomuniformmax)r" retry_numberdelay jitter_amounts r&_calculate_delay$ToolRetryMiddleware._calculate_delays   # %&&E&&$*=*=|*KLEE>>* ;;519!DLMFNNM>=IIE5ME r,c\[U5RnUS:XaSOSnSUSUSUSU3$)zFormat 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. attemptattemptszTool 'z' failed after  z with )type__name__)r"r)r/ attempts_madeexc_type attempt_words r&_format_failure_message+ToolRetryMiddleware._format_failure_messagesB9%%$1Q$6yJ  {/-,vV^U_``r,cURS:XaUe[UR5(aURU5nOURXU5n[UUUSS9$)avHandle 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. raiseerror)content tool_call_idr status)rr.rFr)r"r)rLr/rCrKs r&_handle_failure#ToolRetryMiddleware._handle_failures]" ??g %I DOO $ $ooc*G229=QG%   r,cUR(aURROURSnURU5(dU"U5$URSn[ UR S-5H nU"U5s $ Sn [U 5e![ anUS-nURU5(dURX4Xg5sSnAs $XPR :a9URU5nUS:a[R"U5 SnAMSnAMURX4Xg5sSnAs $SnAff=f)aIntercept 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). r idr=Nr2Unexpected: retry loop completed without returning) r$r tool_callr*ranger Exceptionr0rNr:timesleep RuntimeError r"requesthandlerr)rLr>r/rCr8r#s r&wrap_tool_call"ToolRetryMiddleware.wrap_tool_call s%*1GLL%%7;L;LV;T &&y117# #((. T--12G ]w''3.C3+ ] '! 33C88// \\--- 11':Eqy 5))!  // \\# ]s0B D=#,D8D=EEEEE) r!rrrrrrrr)rintrzlist[BaseTool | str] | Nonerz9tuple[type[Exception], ...] | Callable[[Exception], bool]rz?Literal['raise', 'return_message'] | Callable[[Exception], str]rfloatrrcrrcrboolreturnNone)r)rrerd)r/rUrerd)r7rbrerc)r)rr/rUrCrbrer) r)rrLz str | Noner/rUrCrbrer)rZr r[z2Callable[[ToolCallRequest], ToolMessage | Command]reToolMessage | Command)rZr r[z=Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]rerg)rB __module__ __qualname____firstlineno____doc__rUrr*r0r:rFrNr\r`__static_attributes__ __classcell__)r%s@r&rrs'Xz-1OXl  #"JJ+ J L J LJJJJJ JJX . .2 a  ,6 =F WZ  @/  / D/   / b/  / O/   / / r,r)rk __future__rr_r4rVtypingrrlangchain_core.messagesr!langchain.agents.middleware.typesrcollections.abcrr langgraph.typesr r langchain.toolsr rr,r&rvs:'" )/=3'A(i /i r,