KKi  SrSSKJr SSKrSSKrSSKrSSKJrJr SSK J r J r SSK J r J r SSKJr SSKJrJrJrJrJrJrJrJrJrJrJr SS KJrJrJrJ r J!r!J"r" SS K#J$r$J%r%J&r& SS K'J(r(J)r) SS K'J*r+ SS K,J-r-J.r.J/r/J0r0 SSK1J2r2 SSK3J4r4 SSK5J6r6 SSK7J8r8 SSK9J:r:J;r;Jr>J?r? SSK@JArAJBrB \(aSSKJCrC SSKDJErE SSKFJGrG \A"S\HS9rI\A"SSS9rJSrKSrLSrMSrN"SS \S!S"9rO\ "S#S$55rP\\P\\P/\!\:-4/\!\:-4rQ\\P\\P/\\!\:-4/\\!\:-4rR"S%S&\5rSSS+jrWS?S,jrXS@S-jrY\ "S.S/55rZ"S0S1\25r[SASBS2jjr\\ "S3S4\/\\J\I455r]"S5S6\)5r^"S7S8\)5r_SCS9jr`SDS:jraSES;jrbg)FaTool execution node for LangGraph workflows. This module provides prebuilt functionality for executing tools in LangGraph. Tools are functions that models can call to interact with external systems, APIs, databases, or perform computations. The module implements design patterns for: - Parallel execution of multiple tool calls for efficiency - Robust error handling with customizable error messages - State injection for tools that need access to graph state - Store injection for tools that need persistent storage - Command-based state updates for advanced control flow Key Components: - [`ToolNode`][langgraph.prebuilt.ToolNode]: Main class for executing tools in LangGraph workflows - [`InjectedState`][langgraph.prebuilt.InjectedState]: Annotation for injecting graph state into tools - [`InjectedStore`][langgraph.prebuilt.InjectedStore]: Annotation for injecting persistent store into tools - [`ToolRuntime`][langgraph.prebuilt.ToolRuntime]: Runtime information for tools, bundling together `state`, `context`, `config`, `stream_writer`, `tool_call_id`, and `store` - [`tools_condition`][langgraph.prebuilt.tools_condition]: Utility function for conditional routing based on tool calls Typical Usage: ```python from langchain_core.tools import tool from langchain.tools import ToolNode @tool def my_tool(x: int) -> str: return f"Result: {x}" tool_node = ToolNode([my_tool]) ``` ) annotationsN) AwaitableCallable)copydeepcopy) dataclassreplace) UnionType) TYPE_CHECKING AnnotatedAnyGenericLiteral TypedDictUnioncastget_args get_originget_type_hints) AIMessage AnyMessage RemoveMessageToolCall ToolMessageconvert_to_messages)RunnableConfigget_config_listget_executor_for_config)BaseToolInjectedToolArg)tool)TOOL_MESSAGE_BLOCK_TYPES ToolException_DirectlyInjectedToolArgget_all_basemodel_annotations)RunnableCallable) GraphBubbleUp)REMOVE_ALL_MESSAGES) BaseStore)CommandSend StreamWriter) BaseModelValidationError)TypeVarUnpack)Sequence)Runtime) ErrorDetailsStateT)defaultContextTzLError: {requested_tool} is not a valid tool, try one of [{available_tools}].z)Error: {error} Please fix your mistakes.zvError executing tool '{tool_name}' with kwargs {tool_kwargs} with error: {error} Please fix the error and try again.zuError invoking tool '{tool_name}' with kwargs {tool_kwargs} with error: {error} Please fix the error and try again.c8\rSrSr%SrS\S'S\S'S\S'S rg ) _ToolCallRequestOverridesxz9Possible overrides for ToolCallRequest.override() method.r tool_callrr!r stateN__name__ __module__ __qualname____firstlineno____doc____annotations____static_attributes__r<^/var/www/html/dynamic-report/venv/lib/python3.13/site-packages/langgraph/prebuilt/tool_node.pyr8r8xsC N JrEr8F)totalc^\rSrSr%SrS\S'S\S'S\S'S \S 'SS jrSS jrS rg)ToolCallRequestaBTool execution request passed to tool call interceptors. Attributes: tool_call: Tool call dict with name, args, and id from model output. tool: BaseTool instance to be invoked, or None if tool is not registered with the `ToolNode`. When tool is `None`, interceptors can handle the request without validation. If the interceptor calls `execute()`, validation will occur and raise an error for unregistered tools. state: Agent state (`dict`, `list`, or `BaseModel`). runtime: LangGraph runtime context (optional, `None` if outside graph). rr:BaseTool | Noner!r r; ToolRuntimeruntimecSSKn[US5(a[X5(d[RXU5 gUR SUS3[ SS9 [RXU5 g)zRaise deprecation warning when setting attributes directly. Direct attribute assignment is deprecated. Use the `override()` method instead. rN__dataclass_fields__zSetting attribute 'zt' on ToolCallRequest is deprecated. Use the override() method instead to create a new instance with modified values.) stacklevel)warningshasattrobject __setattr__warnDeprecationWarning)selfnamevaluerRs rFrUToolCallRequest.__setattr__sm t344GDr?r@rArBrCrUr^rDr<rErFrIrIs:   J 2&*<* *rErIc:\rSrSr%SrS\S'S\S'S\S'S rg ) ToolCallWithContextia}ToolCall with additional context for graph state. This is an internal data structure meant to help the `ToolNode` accept tool calls with additional context (e.g. state) when dispatched using the Send API. The Send API is used in create_agent to distribute tool calls in parallel and support human-in-the-loop workflows where graph execution may be paused for an indefinite time. rr:z!Literal['tool_call_with_context']_ToolCallWithContext__typer r;r<Nr=r<rErFrdrds$  -- J6rErdc[U[5(d,[U[5(a[SU55(aU$[R "USS9$![ a [U5s$f=f)a<Convert tool output to `ToolMessage` content format. Handles `str`, `list[dict]` (content blocks), and arbitrary objects by attempting JSON serialization with fallback to str(). Args: output: Tool execution output of any type. Returns: String or list of content blocks suitable for `ToolMessage.content`. c3# UH4n[U[5=(a URS5[;v M6 g7f)typeN) isinstancedictgetr").0xs rF %msg_content_output..?s4  q$  MAEE&M5M$M Ms<>F) ensure_ascii)rir`listalljsondumps Exception)outputs rFmsg_content_outputrw1sn&#64       zz&u55 6{sAA21A2cH^\rSrSrSrSSU4SjjjrSrU=r$)ToolInvocationErroriOzAn error occurred while invoking a tool due to invalid arguments. This exception is only raised when invoking a tool using the `ToolNode`! c>Ubm/nUHSnSRSURSS555nURSS5nURUSU35 MU S RU5n O [U5n [R XU S 9UlXlX0lX l X@l [T U]1UR 5 g) a1Initialize the ToolInvocationError. Args: tool_name: The name of the tool that failed. source: The exception that occurred. tool_kwargs: The keyword arguments that were passed to the tool. filtered_errors: Optional list of filtered validation errors excluding injected arguments. N.c38# UHn[U5v M g7fN)r`)rllocs rFrn/ToolInvocationError.__init__..js"L7K3s887Ksr~r<msgz Unknown errorz:  ) tool_name tool_kwargserror) joinrkappendr`TOOL_INVOCATION_ERROR_TEMPLATEformatmessagerrsourcefiltered_errorssuper__init__) rXrrrrerror_str_partsrloc_strrerror_display_str __class__s rFrToolInvocationError.__init__Us"  & O((("Luyy7K"LLii7&&'"SE':;)!% / :  #F 5<<@Q=  #& . &rE)rrrrrr}) rr`rr.rdict[str, Any]rzlist[ErrorDetails] | Nonerarb)r>r?r@rArBrrD __classcell__rs@rFryryOsG6: #'#' #'$ #' 3 #'  #'#'rErycH[U[5(a UR$Ue)zDefault error handler for tool errors. If the tool is a tool invocation error, return its message. Otherwise, raise the error. )riryr)es rF_default_handle_tool_errorsr{s! !())yy GrEcN[U[[45(d*[U[5(a3[ U[ 5(a[ R[U5S9nU$[U[5(aUnU$[U5(a U"U5nU$SU3n[U5e)a|Generate error message content based on exception handling configuration. This function centralizes error message generation logic, supporting different error handling strategies configured via the `ToolNode`'s `handle_tool_errors` parameter. Args: e: The exception that occurred during tool execution. flag: Configuration for how to handle the error. Can be: - bool: If `True`, use default error template - str: Use this string as the error message - Callable: Call this function with the exception to get error message - tuple: Not used in this context (handled by caller) Returns: A string containing the error message to include in the `ToolMessage`. Raises: ValueError: If flag is not one of the supported types. !!! note The tuple case is handled by the caller through exception type checking, not by this function directly. )rzVGot unexpected type of `handle_tool_error`. Expected bool, str or callable. Received: ) ribooltuplerh issubclassruTOOL_CALL_ERROR_TEMPLATErreprr`callable ValueError)rflagcontentrs rF_handle_tool_errorrsB$u &&4:dI#>#>*11Q1@ N D#   N $q' N &&*V - orEcz[R"U5n[URR 55nU(aUSR S;a[ U5S:XaUSnOUSn[U5nUR U;a[UR5nU[[4;aR[UR5n[SU55(a [U5$SURS3n[U5eXCR n[ UR";aU4$SUS3n[U5e[ 4$) aInfer exception types handled by a custom error handler function. This function analyzes the type annotations of a custom error handler to determine which exception types it's designed to handle. This enables type-safe error handling where only specific exceptions are caught and processed by the handler. Args: handler: A callable that takes an exception and returns an error message string. The first parameter (after self/cls if present) should be type-annotated with the exception type(s) to handle. Returns: A tuple of exception types that the handler can process. Returns (Exception,) if no specific type information is available for backward compatibility. Raises: ValueError: If the handler's annotation contains non-Exception types or if Union types contain non-Exception types. !!! note This function supports both single exception types and Union types for handlers that need to handle multiple exception types differently. r)rXclsrPc3B# UHn[U[5v M g7fr})rru)rlargs rFrn'_infer_handled_types..sBTcz#y11TzAll types in the error handler error annotation must be Exception types. For example, `def custom_handler(e: Union[ValueError, TypeError])`. Got 'z ' instead.aArbitrary types are not supported in the error handler signature. Please annotate the error with either a specific Exception type or a union of Exception types. For example, `def custom_handler(e: ValueError)` or `def custom_handler(e: Union[ValueError, TypeError])`. Got ')inspect signaturerq parametersvaluesrYlenrr annotationrr rrrrrru__mro__) handlersigparams first_param type_hintsoriginargsrexception_types rF_infer_handled_typesrs:0   G $C #..'') *F !9>>_ ,V1A )K )K#G,   z ) 6 67F%++ 6 67BTBBB ;&(223:? !o%'(8(89NN222&(( ''z 3 S/ ! <rEc[5nU(aUR(a)URURR55 UR(aUR UR5 UR (aUR UR 5 /nUR5HnUS(dMUSSU;dM0UEn[URS5[5(a4USnUR5VVs0sHupxXr;dM Xx_M n nnXS'URU5 M U$s snnf)aFilter validation errors to only include LLM-controlled arguments. When a tool invocation fails validation, only errors for arguments that the LLM controls should be included in error messages. This ensures the LLM receives focused, actionable feedback about parameters it can actually fix. System-injected arguments (state, store, runtime) are filtered out since the LLM has no control over them. This function also removes injected argument values from the `input` field in error details, ensuring that only LLM-provided arguments appear in error messages. Args: validation_error: The Pydantic ValidationError raised during tool invocation. injected_args: The _InjectedArgs structure containing all injected arguments, or None if there are no injected arguments. Returns: List of ErrorDetails containing only errors for LLM-controlled arguments, with system-injected argument values removed from the input field. r~rinput) setr;updatekeysstoreaddrMerrorsrirkrjitemsr) validation_error injected_argsinjected_arg_namesrr error_copy input_dictkv input_copys rF_filter_validation_errorsrs%2$'5     % %m&9&9&>&>&@ A     " "=#6#6 7   " "=#8#8 9*,O!((* < str: ... ``` The resulting `_InjectedArgs` would be: ```python _InjectedArgs( state={ "messages": "messages", # Extract state["messages"] "full_state": None, # Inject entire state }, store="store", # Inject into "store" parameter runtime="runtime", # Inject into "runtime" parameter ) ``` zdict[str, str | None]r; str | NonerrMr<Nr=r<rErFrr2s-^ !  rErc^\rSrSr%SrSrS\S'SS\SSSS.SU4S jjjr\ SS j5r SS jr SS jr SS jr SSjrSSjrSSjrSSjrSSjrSSjrS SjrS!S"SjjrS#SjrSrU=r$)$ToolNodeihuA node for executing tools in LangGraph workflows. Handles tool execution patterns including function calls, state injection, persistent storage, and control flow. Manages parallel execution, error handling. Use `ToolNode` when building custom workflows that require fine-grained control over tool execution—for example, custom routing logic, specialized error handling, or non-standard agent architectures. For standard ReAct-style agents, use [`create_agent`][langchain.agents.create_agent] instead. It uses `ToolNode` internally with sensible defaults for the agent loop, conditional routing, and error handling. Input Formats: 1. **Graph state** with `messages` key that has a list of messages: - Common representation for agentic workflows - Supports custom messages key via `messages_key` parameter 2. **Message List**: `[AIMessage(..., tool_calls=[...])]` - List of messages with tool calls in the last AIMessage 3. **Direct Tool Calls**: `[{"name": "tool", "args": {...}, "id": "1", "type": "tool_call"}]` - Bypasses message parsing for direct tool execution - For programmatic tool invocation and testing Output Formats: Output format depends on input type and tool behavior: **For Regular tools**: - Dict input → `{"messages": [ToolMessage(...)]}` - List input → `[ToolMessage(...)]` **For Command tools**: - Returns `[Command(...)]` or mixed list with regular tool outputs - `Command` can update state, trigger navigation, or send messages Args: tools: A sequence of tools that can be invoked by this node. Supports: - **BaseTool instances**: Tools with schemas and metadata - **Plain functions**: Automatically converted to tools with inferred schemas name: The name identifier for this node in the graph. Used for debugging and visualization. tags: Optional metadata tags to associate with the node for filtering and organization. handle_tool_errors: Configuration for error handling during tool execution. Supports multiple strategies: - `True`: Catch all errors and return a `ToolMessage` with the default error template containing the exception details. - `str`: Catch all errors and return a `ToolMessage` with this custom error message string. - `type[Exception]`: Only catch exceptions with the specified type and return the default error message for it. - `tuple[type[Exception], ...]`: Only catch exceptions with the specified types and return default error messages for them. - `Callable[..., str]`: Catch exceptions matching the callable's signature and return the string result of calling it with the exception. - `False`: Disable error handling entirely, allowing exceptions to propagate. Defaults to a callable that: - Catches tool invocation errors (due to invalid arguments provided by the model) and returns a descriptive error message - Ignores tool execution errors (they will be re-raised) messages_key: The key in the state dictionary that contains the message list. This same key will be used for the output `ToolMessage` objects. Allows custom state schemas with different message field names. Examples: Basic usage: ```python from langchain.tools import ToolNode from langchain_core.tools import tool @tool def calculator(a: int, b: int) -> int: """Add two numbers.""" return a + b tool_node = ToolNode([calculator]) ``` State injection: ```python from typing_extensions import Annotated from langchain.tools import InjectedState @tool def context_tool(query: str, state: Annotated[dict, InjectedState]) -> str: """Some tool that uses state.""" return f"Query: {query}, Messages: {len(state['messages'])}" tool_node = ToolNode([context_tool]) ``` Error handling: ```python def handle_errors(e: ValueError) -> str: return "Invalid input provided" tool_node = ToolNode([my_tool], handle_tool_errors=handle_errors) ``` toolsr`rYNmessages)rYtagshandle_tool_errors messages_keywrap_tool_callawrap_tool_callcz>[T U]URURX#SS9 0Ul0UlX@lXPlX`lXpl UHjn[U[5(d[[SU55n OUn XRU R'[U 5UR U R'Ml g)aInitialize `ToolNode` with tools and configuration. Args: tools: Sequence of tools to make available for execution. name: Node name for graph identification. tags: Optional metadata tags. handle_tool_errors: Error handling configuration. messages_key: State key containing messages. wrap_tool_call: Sync wrapper function to intercept tool execution. Receives ToolCallRequest and execute callable, returns ToolMessage or Command. Enables retries, caching, request modification, and control flow. awrap_tool_call: Async wrapper function to intercept tool execution. If not provided, falls back to wrap_tool_call for async execution. F)rYrtraceztype[BaseTool]N)rr_func_afunc_tools_by_name_injected_args_handle_tool_errors _messages_key_wrap_tool_call_awrap_tool_callrir create_toolrrY_get_all_injected_args) rXrrYrrrrrr!tool_rs rFrToolNode.__init__s: T[[teT358:#5 )- /DdH--#D)94$@A.3   +.DU.KD   +rEcUR$)z,Mapping from tool name to BaseTool instance.)r)rXs rF tools_by_nameToolNode.tools_by_names"""rEc URU5upE[U[U55n/n[XFSS9HVupUR U5n [ U USU UR URURS9n URU 5 MX U/[U5-n [U5n [U RURXLU55nSSS5 URWU5$!,(df  N =fNF)strictid)r; tool_call_idconfigcontextr stream_writer) _parse_inputrrzip_extract_staterLrrrrrrqmap_run_one_combine_tool_outputs)rXrrrM tool_calls input_type config_list tool_runtimescallcfgr; tool_runtime input_typesexecutoroutputss rFrToolNode._funcs "&!2!25!9 %fc*o>  ZUCID''.E&!$Zmm%33 L   .D"lS_4 $V , T]]J]SG- ))':>> - ,s )'C** C8c # URU5upE[U[U55n/n[XFSS9HVupUR U5n [ U USU UR URURS9n URU 5 MX /n [XGSS9H&upU RURXU 55 M( [R"U 6IShvN n URX5$N7fr)rrrrrrLrrrr _arun_oneasynciogatherr)rXrrrMrrrrrrr;rcorosrs rFrToolNode._afunc3s "&!2!25!9 %fc*o>  ZUCID''.E&!$Zmm%33 L   .D"%j"N D LL,G H#O..))'>>/sCC5C3C5c[SU55(dUS:XaU$URU0$/nSnUGHn[U[5(aUR[R La[UR [5(ay[SUR 55(aXU(a-[U[SUR 5UR -S9nM[[R UR S9nMURU5 MURUS:XaU/OURU/05 GM U(aURU5 U$)Nc3B# UHn[U[5v M g7fr})rir*)rlrvs rFrn1ToolNode._combine_tool_outputs..YsEW6:fg..Wrrqc3B# UHn[U[5v M g7fr})rir+)rlsends rFrnr jsK{tJtT22{rz list[Send])goto)graphr) anyrrir*rPARENTrrqrrr rr)rXrrcombined_outputsparent_commandrvs rFrToolNode._combine_tool_outputsRs EWEEE(F27 U9K9KW8U U   *.F&'**LLGNN2"6;;55Kv{{KKK%)0*!%lN4G4G!H6;;!V* *1w~~FKK)X$++F3 '' *f 4VH4;M;MPVx:X#*   # #N 3rEc$URnURnUc.URU5=n(aU$SUSS3n[U5eUR XAR U5n0UESS0En UR X5n [U [.5(aUR1XRU5$[U [,5(a&[3S [5U R655U lU $SUSS [!U 53n[U5e![aBn URRUS5n [X5n [USXSU 5U eSn A ff=f![a e[Gan[UR[ 5(a-[#UR[5(aUR4nO[UR[$5(a URnOV['UR5(a5[UR[ 5(d[)UR5nO[4nUR(a[X5(de[+XRS9n[-UUSUS S S 9sSnA$SnAff=f)a Execute tool call with configured error handling. Args: request: Tool execution request. input_type: Input format. config: Runnable configuration. Returns: ToolMessage or Command. Raises: Exception: If tool fails and handle_tool_errors is False. NTool rY is not registered with ToolNoderhr:rrrrrrYrstatus str | list returned unexpected type: )r:r!_validate_tool_call TypeError_inject_tool_argsrMinvoker.rrkrryr'rurirrhrrrrrrr*_validate_tool_commandrrwrrXrequestrrrr!invalid_tool_messager injected_call call_argsresponseexcinjectedrr handled_typesrs rF_execute_tool_syncToolNode._execute_tool_sync~sp&  || <'+'?'?'EE#E++$v,'GHCC. ..t__dK :}:fk: 3  ;;y9h h ( (..x9J9JJW W h , ,#L2DXEUEU2VWH Od6l^#>tH~>NOnw# ..224<@";C"J)L#F|_  $   $22D99j(()??"&!9!9 ; D44e<< $ 8 8 $2233J(($==!5T5M5M N "+ ++:a3O3O)1I1IJG&\!$Z  / s70D E=EEEJ0DJ J Jc^^^ TRRUS5n[UUURUS9nURm TR cTR UTT 5$S U UU4SjjnTR XV5$![aVnTR(de[UTRS9n[UURSURSSS9sSnA$SnAff=f) zExecute single tool call with wrap_tool_call wrapper if configured. Args: call: Tool call dict. input_type: Input format. tool_runtime: Tool runtime. Returns: ToolMessage or Command. rYr:r!r;rMNc*>TRUTT5$)>Execute tool with given request. Can be called multiple times.r+reqrrrXs rFexecute"ToolNode._run_one..execute**3 FC CrErrrrr3rIraToolMessage | Command) rrkrIr;rrr+rurrrr:) rXrrrr! tool_requestr4rrrs ` ` @rFrToolNode._run_ones$!!%%d6l3'$$  $$    '**<VL L D D '' > > ++(1I1IJG!++F3)33D9   s/B C  A CC C c@# URnURnUc.URU5=n(aU$SUSS3n[U5eUR XAR U5n0UESS0En UR X5IShvN n [U [.5(aUR1XRU5$[U [,5(a&[3S [5U R655U lU $SUSS [!U 53n[U5eN![aBn URRUS5n [X5n [USXSU 5U eSn A ff=f![a e[Gan[UR[ 5(a-[#UR[5(aUR4nO[UR[$5(a URnOV['UR5(a5[UR[ 5(d[)UR5nO[4nUR(a[X5(de[+XRS9n[-UUSUS S S 9sSnA$SnAff=f7f)aExecute tool call asynchronously with configured error handling. Args: request: Tool execution request. input_type: Input format. config: Runnable configuration. Returns: ToolMessage or Command. Raises: Exception: If tool fails and handle_tool_errors is False. NrrYrrhr:rrrrrrr)r:r!rrrrMainvoker.rrkrryr'rurirrhrrrrrrr*r!rrwrr"s rF_execute_tool_asyncToolNode._execute_tool_asyncsy&  || <'+'?'?'EE#E++$v,'GHCC. ..t__dK :}:fk: 3  !%i!@@h h ( (..x9J9JJW W h , ,#L2DXEUEU2VWH Od6l^#>tH~>NOnyA" ..224<@";C"J)L#F|_  $   $22D99j(()??"&!9!9 ; D44e<< $ 8 8 $2233J(($==!5T5M5M N "+ ++:a3O3O)1I1IJG&\!$Z  / sbA.J2DDD B JD E$"=EE$$E''J# TRUTT5IShvN $N7f)r0N)r=r2s rFr4#ToolNode._arun_one..executes!11#z6JJ JJs !!c*>TRUTT5$)z'Sync execute fallback for sync wrapper.r1r2s rF _sync_execute)ToolNode._arun_one.._sync_executer6rEToolCallWrapperrrrrr7)rrkrIr;rrrr=rrurrrr:) rXrrrr!r9r4rCrrrs ` ` @rFrToolNode._arun_oneysJ$!!%%d6l3'$$  $$  (T-A-A-I11, FSS S K K D D  $$0!22<III#'(94;O;O#PD '' D D#TJ ++(1I1IJG!++F3)33D9   saA1E 6C"7E !C&1C$2C&5E 6+C&!E $C&& E0A E;E<E EE c[U[5(aF[US[5(a)USRS5S:XaSn[ SU5nX24$SnUnO[U[5(a+URS5S:Xa[ S U5nSnUS/U4$[U[5(a&URUR /5=n(aS nO-[ XR /5=n(aS nO S n[U5e[S [U555n[UR5nX24$![a S n[U5ef=f)Nrhr:rzlist[ToolCall]rq__typetool_call_with_contextrdrjzNo message found in inputc3T# UHn[U[5(dMUv M g7fr})rir)rlms rFrn(ToolNode._parse_input..s%-aAy1I-s( (zNo AIMessage found in input) rirqrjrkrrgetattrrnextreversed StopIterationr)rXrrrrinput_with_ctxrlatest_ai_messages rFrToolNode._parse_inputsX eT " "%)T**uRy}}V/D /S) !"2E: !--JH ud # # ((;?W(W ""7?N%J";/0*< < t $ $ $"4"4b9 9H 9J (:(:B? ?X ?J-CS/ ! " $%#H-%! +667 %%  "/CS/ ! "s D88EcUSnX R;aT[URR55n[R USR U5S9n[ XBUSSS9$g)NrY, )requested_toolavailable_toolsrr)rYrr)rrqr INVALID_TOOL_NAME_ERROR_TEMPLATErrr)rXrrWall_tool_namesrs rFrToolNode._validate_tool_callssf !3!3 3!$"4"4"9"9";G4:g rEcd[U[5(aURS5S:XaUS$U$)zExtract state from input, handling ToolCallWithContext if present. Args: input: The input which may be raw state or ToolCallWithContext. Returns: The actual state to pass to wrap_tool_call wrappers. rIrJr;)rirjrk)rXrs rFrToolNode._extract_states1 eT " "uyy':>V'V> ! rEcXURRUS5nU(dUb [U5nU(dU$[U5n0nUR(Ga`URn[ U[ 5(a[ URR55n[U5S:XaUSUR:XdUScURU0nOdSUSS3n [SURR555(a!SRSU55n U S U S 3- n [U 5e[ U[5(a3URR5HupU (aX|OUXk'M O9URR5HupU (a [X|5OUXk'M UR (a2UR c S n [U 5eUR XdR 'UR"(aX&UR"'0US EUEUS 'U$) a>Inject graph state, store, and runtime into tool call arguments. This is an internal method that enables tools to access graph context that should not be controlled by the model. Tools can declare dependencies on graph state, persistent storage, or runtime context using InjectedState, InjectedStore, and ToolRuntime annotations. This method automatically identifies these dependencies and injects the appropriate values. The injection process preserves the original tool call structure while adding the necessary context arguments. This allows tools to be both model-callable and context-aware without exposing internal state management to the model. Args: tool_call: The tool call dictionary to augment with injected arguments. Must contain 'name', 'args', 'id', and 'type' fields. tool_runtime: The ToolRuntime instance containing all runtime context (state, config, store, context, stream_writer) to inject into tools. tool: Optional tool instance. When provided, allows injection for dynamically registered tools that are not in self.tools_by_name (e.g., tools added via middleware's wrap_tool_call). Returns: A new ToolCall dictionary with the same structure as the input but with additional arguments injected based on the tool's annotation requirements. Raises: ValueError: If a tool requires store injection but no store is provided, or if state injection requirements cannot be satisfied. !!! note This method is called automatically during tool execution. It should not be called from outside the `ToolNode`. rYrrz Invalid input to ToolNode. Tool z$ requires graph state dict as input.c3$# UHov M g7fr}r<)rl state_fields rFrn-ToolNode._inject_tool_args..CsR:Q;;:QsrVc36# UHo(dM Uv M g7fr}r<)rlfs rFrnraDs7X?aVW?s  z State should contain fields r{zgCannot inject store into tools with InjectedStore annotations - please compile your graph with a store.r)rrkrrr;rirqrrrrrrrjrrNrrM)rXr:rr!r)tool_call_copyrr;required_fieldserr_msgrequired_fields_strtool_argr`rs rFrToolNode._inject_tool_argssN&&**9V+<=D,.d3H #' ?  >>> &&E%&&"&x~~'<'<'>"?(A-'*d.@.@@$Q'/!//7E;9V;L:MN56R(..:O:O:QRRR.2ii7X?7X.X+;>!!)>!o%,8,>,>M.. )   .:(** +!LN6$:!Lm!LvrEc.[UR[5(a{US;a.SURSURSUSS3n[ U5e[ U5n[ SUR5=(d 0nURUR/5nO`[UR[5(a?US:wa!S URSUSS3n[ U5e[ U5nURnOU$[U5nU[[S 9/:XaU$S nUH;n [U [5(dMU RUS :XdM/USU lS nM= URc+U(d$US:XaSOSn SUSSUSU S3n[ U5eU$)N)rjrzFTools can provide a dict in Command.update only when using dict with 'z' key as ToolNode input, got: z for tool 'rY'rrqzpTools can provide a list of messages in Command.update only when using list of messages as ToolNode input, got: )rFrTrjz]`Command(update={"messages": [ToolMessage("Success", tool_call_id=tool_call_id), ...]}, ...)`zO`Command(update=[ToolMessage("Success", tool_call_id=tool_call_id), ...], ...)`zDExpected to have a matching ToolMessage in Command.update for tool 'z', got: z. Every tool call (LLM requesting to call a tool) in the message history MUST have a corresponding ToolMessage. You can fix it by modifying the tool to return r{)rirrjrrrrrkrqrrr(rrrYr) rXcommandrrrupdated_command state_updatemessages_updatehas_matching_tool_messagerexample_updates rFr!ToolNode._validate_tool_commandgs gnnd + +!77!//01#NN+;tF|nAG !o%&w/O 0/2H2HIORL*..t/A/A2FO  - -V##NN+;tF|nAG !o%&w/O-44ON.o> }0CDE E" "$)!&Gg{33##tDz1#F| ,0) '  (1J'SR !&\N(?2CDBCQAQQR T S/ !rE)rrrrrr)rzSequence[BaseTool | Callable]rYr`rzlist[str] | NonerObool | str | Callable[..., str] | type[Exception] | tuple[type[Exception], ...]rr`rzToolCallWrapper | NonerzAsyncToolCallWrapper | Nonerarb)razdict[str, BaseTool])r-list[AnyMessage] | dict[str, Any] | BaseModelrrrMr2rar )rzlist[ToolMessage | Command]r%Literal['list', 'dict', 'tool_calls']raz@list[Command | list[ToolMessage] | dict[str, list[ToolMessage]]])r#rIrrurrrar8)rrrrurrLrar8)rrtrazr?r@rArBrYrCrrpropertyrrrrr+rr=rrrrrr!rDrrs@rFrrhswtlD# !% )D&157;+L,+L +L  +L & +L+L/+L5+L +L+LZ##?<?? ? ?@?<?? ? ?>* ,* :*  J * X` `:` `  `D55:5" 5  5n` `:` `  `D==:=" =  =~*&<*& F*&X  B  6 &!% ee"e e  eNFFF: F  FFrErc>[U[5(aUSnOW[U[5(aURU/5=n(d[ X/5=n(aUSnOSU3n[ U5e[ US5(a[UR5S:agg)aConditional routing function for tool-calling workflows. This utility function implements the standard conditional logic for ReAct-style agents: if the last `AIMessage` contains tool calls, route to the tool execution node; otherwise, end the workflow. This pattern is fundamental to most tool-calling agent architectures. The function handles multiple state formats commonly used in LangGraph applications, making it flexible for different graph designs while maintaining consistent behavior. Args: state: The current graph state to examine for tool calls. Supported formats: - Dictionary containing a messages key (for `StateGraph`) - `BaseModel` instance with a messages attribute messages_key: The key or attribute name containing the message list in the state. This allows customization for graphs using different state schemas. Returns: Either `'tools'` if tool calls are present in the last `AIMessage`, or `'__end__'` to terminate the workflow. These are the standard routing destinations for tool-calling conditional edges. Raises: ValueError: If no messages can be found in the provided state format. Example: Basic usage in a ReAct agent: ```python from langgraph.graph import StateGraph from langchain.tools import ToolNode from langchain.tools.tool_node import tools_condition from typing_extensions import TypedDict class State(TypedDict): messages: list graph = StateGraph(State) graph.add_node("llm", call_model) graph.add_node("tools", ToolNode([my_tool])) graph.add_conditional_edges( "llm", tools_condition, # Routes to "tools" or "__end__" {"tools": "tools", "__end__": "__end__"}, ) ``` Custom messages key: ```python def custom_condition(state): return tools_condition(state, messages_key="chat_history") ``` !!! note This function is designed to work seamlessly with `ToolNode` and standard LangGraph patterns. It expects the last message to be an `AIMessage` when tool calls are present, which is the standard output format for tool-calling language models. rHz/No messages found in input state to tool_edge: rrr__end__) rirqrjrkrNrrSrr)r;r ai_messagerrs rFtools_conditionrzsD%2Y UD ! !599\23N'Nx'NE444b\ ?wGoz<((S1F1F-G!-K rEcV\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S'Srg)rLia*Runtime context automatically injected into tools. !!! note This is distinct from `Runtime` (from `langgraph.runtime`), which is injected into graph nodes and middleware. `ToolRuntime` includes additional tool-specific attributes like `config`, `state`, and `tool_call_id` that `Runtime` does not have. When a tool function has a parameter named `runtime` with type hint `ToolRuntime`, the tool execution system will automatically inject an instance containing: - `state`: The current graph state - `tool_call_id`: The ID of the current tool call - `config`: `RunnableConfig` for the current execution - `context`: Runtime context (shared with `Runtime`) - `store`: `BaseStore` instance for persistent storage (shared with `Runtime`) - `stream_writer`: `StreamWriter` for streaming output (shared with `Runtime`) No `Annotated` wrapper is needed - just use `runtime: ToolRuntime` as a parameter. Example: ```python from langchain_core.tools import tool from langchain.tools import ToolRuntime @tool def my_tool(x: int, runtime: ToolRuntime) -> str: """Tool that accesses runtime context.""" # Access state messages = tool_runtime.state["messages"] # Access tool_call_id print(f"Tool call ID: {tool_runtime.tool_call_id}") # Access config print(f"Run ID: {tool_runtime.config.get('run_id')}") # Access runtime context user_id = tool_runtime.context.get("user_id") # Access store tool_runtime.store.put(("metrics",), "count", 1) # Stream output tool_runtime.stream_writer.write("Processing...") return f"Processed {x}" ``` !!! note This is a marker class used for type checking and detection. The actual runtime object will be constructed during tool execution. r4r;r6rrrr,rrrzBaseStore | Nonerr<Nr=r<rErFrLrLs-7r M   rErLc&\rSrSrSrSSSjjrSrg) InjectedStateiCa% Annotation for injecting graph state into tool arguments. This annotation enables tools to access graph state without exposing state management details to the language model. Tools annotated with `InjectedState` receive state data automatically during execution while remaining invisible to the model's tool-calling interface. Args: field: Optional key to extract from the state dictionary. If `None`, the entire state is injected. If specified, only that field's value is injected. This allows tools to request specific state components rather than processing the full state structure. Example: ```python from typing import List from typing_extensions import Annotated, TypedDict from langchain_core.messages import BaseMessage, AIMessage from langchain.tools import InjectedState, ToolNode, tool class AgentState(TypedDict): messages: List[BaseMessage] foo: str @tool def state_tool(x: int, state: Annotated[dict, InjectedState]) -> str: '''Do something with state.''' if len(state["messages"]) > 2: return state["foo"] + str(x) else: return "not enough messages" @tool def foo_tool(x: int, foo: Annotated[str, InjectedState("foo")]) -> str: '''Do something else with state.''' return foo + str(x + 1) node = ToolNode([state_tool, foo_tool]) tool_call1 = {"name": "state_tool", "args": {"x": 1}, "id": "1", "type": "tool_call"} tool_call2 = {"name": "foo_tool", "args": {"x": 1}, "id": "2", "type": "tool_call"} state = { "messages": [AIMessage("", tool_calls=[tool_call1, tool_call2])], "foo": "bar", } node.invoke(state) ``` ```python [ ToolMessage(content="not enough messages", name="state_tool", tool_call_id="1"), ToolMessage(content="bar2", name="foo_tool", tool_call_id="2"), ] ``` !!! note - `InjectedState` arguments are automatically excluded from tool schemas presented to language models - `ToolNode` handles the injection process during execution - Tools can mix regular arguments (controlled by the model) with injected arguments (controlled by the system) - State injection occurs after the model generates tool calls but before tool execution NcXlg)z*Initialize the `InjectedState` annotation.Nfield)rXrs rFrInjectedState.__init__s rErr})rrrarb)r>r?r@rArBrrDr<rErFr}r}CsDLrEr}c\rSrSrSrSrg) InjectedStoreia Annotation for injecting persistent store into tool arguments. This annotation enables tools to access LangGraph's persistent storage system without exposing storage details to the language model. Tools annotated with `InjectedStore` receive the store instance automatically during execution while remaining invisible to the model's tool-calling interface. The store provides persistent, cross-session data storage that tools can use for maintaining context, user preferences, or any other data that needs to persist beyond individual workflow executions. !!! warning `InjectedStore` annotation requires `langchain-core >= 0.3.8` Example: ```python from typing_extensions import Annotated from langgraph.store.memory import InMemoryStore from langchain.tools import InjectedStore, ToolNode, tool @tool def save_preference( key: str, value: str, store: Annotated[Any, InjectedStore()] ) -> str: """Save user preference to persistent storage.""" store.put(("preferences",), key, value) return f"Saved {key} = {value}" @tool def get_preference( key: str, store: Annotated[Any, InjectedStore()] ) -> str: """Retrieve user preference from persistent storage.""" result = store.get(("preferences",), key) return result.value if result else "Not found" ``` Usage with `ToolNode` and graph compilation: ```python from langgraph.graph import StateGraph from langgraph.store.memory import InMemoryStore store = InMemoryStore() tool_node = ToolNode([save_preference, get_preference]) graph = StateGraph(State) graph.add_node("tools", tool_node) compiled_graph = graph.compile(store=store) # Store is injected automatically ``` Cross-session persistence: ```python # First session result1 = graph.invoke({"messages": [HumanMessage("Save my favorite color as blue")]}) # Later session - data persists result2 = graph.invoke({"messages": [HumanMessage("What's my favorite color?")]}) ``` !!! note - `InjectedStore` arguments are automatically excluded from tool schemas presented to language models - The store instance is automatically injected by `ToolNode` during execution - Tools can access namespaced storage using the store's get/put methods - Store injection requires the graph to be compiled with a store instance - Multiple tools can share the same store instance for data consistency r<N)r>r?r@rArBrDr<rErFrrsGrErcJ^[UT5(d&[U[5(a[UT5(ag[U5nU[Ld U[ La[ U4Sj[U555$Ub,UTLd&[U[5(a[UT5(agg)aCheck if a type argument represents an injection annotation. This utility function determines whether a type annotation indicates that an argument should be injected with state or store data. It handles both direct annotations and nested annotations within Union or Annotated types. Args: type_arg: The type argument to check for injection annotations. injection_type: The injection type to look for (InjectedState or InjectedStore). Returns: True if the type argument contains the specified injection annotation. Tc3<># UHn[UT5v M g7fr}) _is_injection)rltainjection_types rFrn _is_injection..sR?Q=^44?QsF)rirhrrrr rr)type_argrorigin_s ` rFrrs"(N++8T""z(N'K'K"G%7i/Rx?QRRR>! w % %*Wn*M*M rEc[U5nUVs/sHn[X15(dMUPM nn[U5S:aSURSU3n[ U5e[U5S:XaUS$[X5(aggs snf)aExtract injection instance from a type annotation. Args: type_: The type annotation to check. injection_type: The injection type to look for. Returns: The injection instance if found, True if injection marker found without instance, None otherwise. rz-A tool argument should not be annotated with z more than once. Found: rTN)rrrr>r)type_r type_argsrmatchesrs rF_get_injection_from_typersI'Nis=+MsiGN 7|a;Nrs%N# /*     ;4 ;*7*77/-()* 4 ( :t ,S!H+ +  B*B* B*Jh0+2GGHI'GR h0)K'