tj HdZddlmZddlmZmZmZddlmZddl m Z ddl m Z m Z mZmZerXddlmZmZddlmZdd lmZdd l mZdd lmZeeegeeezd zfZ eeegeeeezd zfZ Gd de e eeefZd S)z!Tool error middleware for agents.) annotations) TYPE_CHECKINGAnycast) ToolMessage) GraphBubbleUp)AgentMiddleware AgentStateContextT ResponseT) AwaitableCallable) ContentBlock)Command)ToolCallRequest)BaseToolNcHeZdZdZ dddddfd ZddZddZddZxZS)ToolErrorMiddlewareusReturn selected tool-execution exceptions to the model as error `ToolMessage`s. `on_error` is called for each exception raised by tool execution. Return content (a `str` or a list of content blocks) to convert the exception into a `ToolMessage(status="error")`; return `None` — or simply don't return — to let the exception propagate (halting the run). Handling is therefore opt-in — exceptions you do not return content for propagate unchanged, so arbitrary internal exceptions are never serialized to the model or end user unless you choose to surface them. Langgraph control-flow signals (interrupts, parent commands) always propagate and never reach `on_error`. Prefer returning content that names the exception type over the raw exception message, which may carry sensitive or internal detail. Provide at least one of `on_error` or `aon_error`. `aon_error` handles errors on the async execution path (falling back to `on_error` when omitted); the sync path only ever calls `on_error`. For async-only usage, pass `aon_error` alone — running such a middleware on the sync path raises, since the async handler cannot be awaited there. This middleware does not retry. For retries, compose with `ToolRetryMiddleware` placed *inner* and configured with `on_failure="error"` so exceptions reach this middleware. This middleware only sees exceptions raised by tool *execution*. Argument-binding and validation errors are handled upstream by `ToolNode` (converted to an error `ToolMessage` before the tool runs), so they do not reach `on_error`. Example: ```python from langchain.agents import create_agent from langchain.agents.middleware import ToolErrorMiddleware def on_error(exc: Exception, request: ToolCallRequest) -> str | None: if isinstance(exc, ValueError): return f"`{request.tool_call['name']}` failed; fix the input and retry." return None # propagate everything else agent = create_agent(model, tools=[...], middleware=[ToolErrorMiddleware(on_error)]) ``` N) aon_errortoolson_errorOnError | NonerAOnError | Nonerlist[BaseTool | str] | NonereturnNonect||d}t|||_||_||d|D|_nd|_g|_dS)uInitialize `ToolErrorMiddleware`. Args: on_error: Handler called for each exception raised by tool execution. Return content (`str` or list of content blocks) to convert the exception into an error `ToolMessage`. Return `None` — or simply don't return — to let the exception propagate. Falling through without a return therefore re-raises, so handle only the exceptions you mean to. Receives the exception and the tool call request (tool name, args, call id). Used on the sync path and, unless `aon_error` is given, on the async path. aon_error: Optional async handler, used on the async execution path. Falls back to `on_error` when not provided. tools: Optional list of tools or tool names to apply handling to. If `None`, applies to all tools. Raises: ValueError: If neither `on_error` nor `aon_error` is provided. Nz;ToolErrorMiddleware requires `on_error` and/or `aon_error`.cJg|] }t|ts|jn|!S) isinstancestrname).0tools d/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/langchain/agents/middleware/tool_error.py z0ToolErrorMiddleware.__init__..ps. d d dVZ*T32G2G!QT d d d)super__init__ ValueErrorrr _tool_filterr)selfrrrmsg __class__s r%r)zToolErrorMiddleware.__init__Ks2    1OCS// !  " +   d d^c d d dD   $D  r' tool_namer!boolc&|jdS||jvS)z2Check if error handling should apply to this tool.NT)r+)r,r/s r%_should_handle_toolz'ToolErrorMiddleware._should_handle_toolvs   $4D---r'requestrhandler7Callable[[ToolCallRequest], ToolMessage | Command[Any]]ToolMessage | Command[Any]c|jr |jjn |jd}||s ||S ||S#t$rt $rh}|jd}t|||||}|ttd||jd|dcYd}~Sd}~wwxYw)a9Intercept tool execution and convert handled exceptions to error messages. Args: request: Tool call request with call dict, `BaseTool`, state, and runtime. handler: Callable to execute the tool. Returns: `ToolMessage` or `Command` (the final result). r"Nz^ToolErrorMiddleware has no sync `on_error`; run async (ainvoke/astream) or provide `on_error`. str | list[str | dict[Any, Any]]iderrorcontent tool_call_idr"status) r$r" tool_callr2r Exceptionr RuntimeErrorrr)r,r3r4r/excr-r<s r%wrap_tool_callz"ToolErrorMiddleware.wrap_tool_call|s*1TGL%%7;LV;T '' 22 $77## # 77## #       }$?#3''S0mmC11G?II$.t4        s A C !AC>C C BCallable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]]cK|jr |jjn |jd}||s||d{VS ||d{VS#t$rt $r|}|j|||d{V}n|j|||}n|ttd||jd|dcYd}~Sd}~wwxYw)zAsync version of `wrap_tool_call`. Uses `aon_error` if provided, otherwise the sync `on_error`. The sync path never awaits. r"Nr8r9r:r;) r$r"r?r2rr@rrrr)r,r3r4r/rBr<s r%awrap_tool_callz#ToolErrorMiddleware.awrap_tool_calls_*1TGL%%7;LV;T '' 22 * )))))))) )  )))))))) )       ~) $sG < <<<<<<<*--W55?II$.t4        s AC+/A1C& C+&C+)N)rrrrrrrr)r/r!rr0)r3rr4r5rr6)r3rr4rDrr6) __name__ __module__ __qualname____doc__r)r2rCrF __classcell__)r.s@r%rrs**\$()&*-1 ))))))))V.... ((((T""""""""r'r)rJ __future__rtypingrrrlangchain_core.messagesrlanggraph.errorsr!langchain.agents.middleware.typesr r r r collections.abcr rrlanggraph.typesrrlangchain.toolsrr@r!listOnErrorAOnErrorrrr'r%rWs''""""""++++++++++//////******^^^^^^^^^^^^;33333333444444''''''AAAAAA(((((( ?3S4 ;M5MPT5TTUG;O4id