@'hY ddlZddlZddlZddlmZmZddlmZddlmZm Z m Z m Z m Z m Z mZmZmZmZddlmZmZmZmZmZddlmZddlmZmZddlmZmZdd lm Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'm(Z(m)Z)dd l*m+Z+ddl,m-Z-ddl.m/Z/m0Z0ddl1m2Z2dZ3dZ4dedee5e6e7ffdZ8de9dee:e5e de5fe;eGdde2Z? d,dee6ee7e5efe%fde5de d fd!Z@Gd"d#eZAGd$d%eZBd&ed'eeeAeeBfde:fd(ZCd)ede7e5e e5ffd*ZDd)ede e5fd+ZEy)-N)copydeepcopy)replace) AnyCallableLiteralOptionalSequenceTupleTypeUnioncastget_type_hints) AIMessage AnyMessageToolCall ToolMessageconvert_to_messages)RunnableConfig)get_config_listget_executor_for_config)BaseToolInjectedToolArg)tool)get_all_basemodel_annotations) BaseModel) Annotatedget_args get_origin) GraphBubbleUp) BaseStore)CommandSend)RunnableCallablezLError: {requested_tool} is not a valid tool, try one of [{available_tools}].z)Error: {error} Please fix your mistakes.outputreturnc 4d}t|tr|St|tr>t|Dcgc]'}t|txr|j d|v)c}r|S t j|dScc}w#t$rt|cYSwxYw)N)image image_urltextjsontypeF) ensure_ascii) isinstancestrlistalldictgetr+dumps Exception)r%recognized_content_block_typesxs c/home/kushmeetdev/Regenta/Chatbot/venv/lib/python3.12/site-packages/langgraph/prebuilt/tool_node.pymsg_content_outputr90s%K"&# FD !c  q$  SAEE&M5S$S S '   ::f59 9  v;  s,A;$BBBeflag.ct|ttfr!tj t |}|St|t r|}|St|r ||}|Std|)N)errorzVGot unexpected type of `handle_tool_error`. Expected bool, str or callable. Received: ) r.booltupleTOOL_CALL_ERROR_TEMPLATEformatreprr/callable ValueError)r:r;contents r8_handle_tool_errorrFEs$u &*11Q1@ N D#  N $q' N &&*V -  handlerc@tj|}t|jj }|r|dj dvrt |dk(r|d}n|d}t|}|j |vrt|j}|turKt|j}td|Dr t|Std|jd||j }t|j vr|fStd|dtfS) Nr)selfclsc3<K|]}t|tywN) issubclassr5).0args r8 z'_infer_handled_types..lsBcz#y1BzAll 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 signaturer0 parametersvaluesnamelenrr annotationr rr1r?rDr5__mro__)rHsigparams first_param type_hintsoriginargsexception_types r8_infer_handled_typesrd]s*   G $C #..'') *F !9>>_ ,V1A )K )K#G,   z ) 6 67F 6 67BTBB ;&$ + 6 67zC ( (8(89NN222&(( ++:7 <rGceZdZUdZdZeed<ddddddeee e fdede e ed ee ee d efeeed ffd ed df fd Zdee eeeefefdede ed efdZdee eeeefefdede ed efdZde ededd e eee eeee efffdZdededded efdZdededded efdZ dee eeeefefde ed e!e eedffdZ"ded e efdZ#dedee eeeefefd efdZ$dede ed efdZ%dedee eeeefefde ed efdZ&d edededd efd!Z'xZ(S)"ToolNodea A node that runs the tools called in the last AIMessage. It can be used either in StateGraph with a "messages" state key (or a custom key passed via ToolNode's 'messages_key'). If multiple tool calls are requested, they will be run in parallel. The output will be a list of ToolMessages, one for each tool call. Tool calls can also be passed directly as a list of `ToolCall` dicts. Args: tools: A sequence of tools that can be invoked by the ToolNode. name: The name of the ToolNode in the graph. Defaults to "tools". tags: Optional tags to associate with the node. Defaults to None. handle_tool_errors: How to handle tool errors raised by tools inside the node. Defaults to True. Must be one of the following: - True: all errors will be caught and a ToolMessage with a default error message (TOOL_CALL_ERROR_TEMPLATE) will be returned. - str: all errors will be caught and a ToolMessage with the string value of 'handle_tool_errors' will be returned. - tuple[type[Exception], ...]: exceptions in the tuple will be caught and a ToolMessage with a default error message (TOOL_CALL_ERROR_TEMPLATE) will be returned. - Callable[..., str]: exceptions from the signature of the callable will be caught and a ToolMessage with the string value of the result of the 'handle_tool_errors' callable will be returned. - False: none of the errors raised by the tools will be caught messages_key: The state key in the input that contains the list of messages. The same key will be used for the output from the ToolNode. Defaults to "messages". The `ToolNode` is roughly analogous to: ```python tools_by_name = {tool.name: tool for tool in tools} def tool_node(state: dict): result = [] for tool_call in state["messages"][-1].tool_calls: tool = tools_by_name[tool_call["name"]] observation = tool.invoke(tool_call["args"]) result.append(ToolMessage(content=observation, tool_call_id=tool_call["id"])) return {"messages": result} ``` Tool calls can also be passed directly to a ToolNode. This can be useful when using the Send API, e.g., in a conditional edge: ```python def example_conditional_edge(state: dict) -> List[Send]: tool_calls = state["messages"][-1].tool_calls # If tools rely on state or store variables (whose values are not generated # directly by a model), you can inject them into the tool calls. tool_calls = [ tool_node.inject_tool_args(call, state, store) for call in last_message.tool_calls ] return [Send("tools", [tool_call]) for tool_call in tool_calls] ``` Important: - The input state can be one of the following: - A dict with a messages key containing a list of messages. - A list of messages. - A list of tool calls. - If operating on a message list, the last message must be an `AIMessage` with `tool_calls` populated. rYtoolsNTmessages)rYtagshandle_tool_errors messages_keyrirj.rkr&ct||j|j||di|_i|_i|_||_||_|D]z}t|ts t|}||j|j<t||j |j<t||j |j<|y)NF)rYritrace)super__init___func_afunc tools_by_nametool_to_state_argstool_to_store_argrjrkr.r create_toolrY_get_state_args_get_store_arg)rJrgrYrirjrktool_ __class__s r8rozToolNode.__init__s T[[t$eT24GI;="4( GEeX.#E*-2D  uzz *2A%2HD # #EJJ /1?1FD " "5:: .  GrGinputconfigstorec|j||\}}t|t|}|gt|z}t|5}g|j |j |||} ddd|j  |S#1swYxYwrO) _parse_inputrrZrmap_run_one_combine_tool_outputs) rJrzr{r| tool_calls input_type config_list input_typesexecutoroutputss r8rpzToolNode._funcs"&!2!25%!@ J%fc*o> !lS_4 $V , dmmZkRG  ))':>>   s !BB cKj||\}tjfd|Dd{}j|S7w)Nc3DK|]}j|ywrO) _arun_one)rQcallr{rrJs r8rSz"ToolNode._afunc..s N4dnnT:v6 Ns )r~asynciogatherr)rJrzr{r|rrrs` ` @r8rqzToolNode._afuncsU"&!2!25%!@ J N: N  ))':>>  s6AAArr)r0r2rctd|Ds|dk(r|S|j|iSg}d}|D]}t|tr|jtj urt|j tr~td|j Drb|r:t|ttt|j |j z}ttj |j }|j||j|dk(r|gn|j|gi|r|j||S)Nc3<K|]}t|tywrO)r.r")rQr%s r8rSz1ToolNode._combine_tool_outputs..sE6:fg.ErTr0c3<K|]}t|tywrO)r.r#)rQsends r8rSz1ToolNode._combine_tool_outputs..sKtJtT2KrT)goto)graphr) anyrkr.r"rPARENTrr0r1rrr#append)rJrrcombined_outputsparent_commandr%s r8rzToolNode._combine_tool_outputssEWEE(F27 T9J9JG8T T   -1 F&'*LLGNN2"6;;5Kv{{KK%)0*!%d4j.2E2E!F!T* *1w~~FKK)X$++F3 '' *f 4VH4;L;Lvh:W# *   # #N 3rGrc|j|x}r|S i|ddi}|j|dj||}t |tr|j|||St |tr7ttt t"ft%|j&|_|St)d|dd t+|#t$r}|d}~wt$r}t |j tr |j }n2t|j rt|j }ntf}|j r t ||s|t||j } t| |d|ddcYd}~Sd}~wwxYw Nr, tool_callrY)r;idr=)rErY tool_call_idstatuszTool z returned unexpected type: )_validate_tool_callrrinvoker r5r.rjr?rCrdrFrr"_validate_tool_commandrr r/r0r9rE TypeErrorr, rJrrr{invalid_tool_messagerzresponser: handled_typesrEs r8rzToolNode._run_one3s $(#;#;D#A A  A' ' 5t5 45E))$v,7>>ufMH@ h (..xzJ J + .#c4i "4X5E5E"F H OV ~%@h@PQ A G $1159'+'>'> $112 4T5L5L M "+ ***Q 2N-QT5L5LM&\!$Z   s**C FC FBF=FFc2K|j|x}r|S i|ddi}|j|dj||d{}t |tr|j|||St |tr7ttt t"ft%|j&|_|St)d|dd t+|7#t$r}|d}~wt$r}t |j tr |j }n2t|j rt|j }ntf}|j r t ||s|t||j } t| |d|ddcYd}~Sd}~wwxYwwr)rrrainvoker r5r.rjr?rCrdrFrr"rrr r/r0r9rErr,rs r8rzToolNode._arun_onejs $(#;#;D#A A  A' '! 5t5 45E!//V =EEeVTTHB h (..xzJ J + .#c4i "4X5E5E"F H OV ~%@h@PQ SU G $1159'+'>'> $112 4T5L5L M "+ ***Q 2N-QT5L5LM&\!$Z  ! sTF-CCC BFC FC F+BF F FFFct|tr:t|dtr|djddk(rd}|}||fSd}|d}nbt|tr&|j|jgx}rd}|d}n,t ||jdx}rd}|d}n t dt|ts t d|jDcgc]}|j|||}}||fScc}w) Nr,rrr0r2zNo message found in inputz Last message is not an AIMessage) r.r0r2r3rkgetattrrDrrinject_tool_args)rJrzr|rrmessagerhrs r8r~zToolNode._parse_inputs eT "%)T*uRy}}V/D /S) " !:--# &+Bi t $eii@Q@QSU6V*V(*VJrlG (9(94@ @X @JrlG89 9'9-?@ @CJBTBT :>D ! !$u 5  :%% sC6c|dx}|jvrPtj|dj|jj }t |||ddSy)NrY, )requested_toolavailable_toolsrr=)rYrr)rr INVALID_TOOL_NAME_ERROR_TEMPLATErAjoinkeysr)rJrrrEs r8rzToolNode._validate_tool_callsm"6l *N43E3E E6==- $ $*<*<*A*A*C D>Gn4:g rGrc |j|d}|rt|trt|j}t |dk(r|d|j k(s|d|j |i}nUd|dd}t d|jDr!djd|D}|d |d z }t|t|tr+|jDcic]\}}||r||n|} }}n1|jDcic]\}}||r t||n|} }}i|d | |d <|Scc}}wcc}}w) NrYrMrz Invalid input to ToolNode. Tool z$ requires graph state dict as input.c3 K|]}|ywrO)rQ state_fields r8rSz)ToolNode._inject_state..sJ{{Js rc3&K|] }|s| ywrOr)rQfs r8rSz)ToolNode._inject_state..s3T!RSA3Tsz State should contain fields .rb) rsr.r0rXrZrkrrrDr2itemsr) rJrrz state_argsrequired_fieldserr_msgrequired_fields_strtool_argrtool_state_argss r8 _inject_statezToolNode._inject_states,,Yv->? *UD1":#4#4#67OO$)#A&$*;*;;"1%-**E27y7H6IJ12Jj6G6G6IJJ*.))3T3T*T'!>?R>SSTUUG )) eT ".8-=-=-?)Hk % ,FO.8-=-=-?)Hk'%5%OO    & s *EEch|j|d}|s|S| tdi|d||i|d<|S)NrYzgCannot inject store into tools with InjectedStore annotations - please compile your graph with a store.rb)rtrD)rJrr| store_args r8 _inject_storezToolNode._inject_storesd**9V+<=   =:    u &rGc|d|jvr|St|}|j||}|j||}|S)atInjects the state and store into the tool call. Tool arguments with types annotated as `InjectedState` and `InjectedStore` are ignored in tool schemas for generation purposes. This method injects them into tool calls for tool invocation. Args: tool_call (ToolCall): The tool call to inject state and store into. input (Union[list[AnyMessage], dict[str, Any], BaseModel]): The input state to inject. store (Optional[BaseStore]): The store to inject. Returns: ToolCall: The tool call with injected state and store. rY)rrrrr)rJrrzr|tool_call_copytool_call_with_statetool_call_with_stores r8rzToolNode.inject_tool_argssS2 V D$6$6 6 #' ?#11.%H#112FN##rGcommandc t|jtr|dvr,td|jd|jd|ddt |}t tttf|jxsi}|j|jg}nXt|jtr<|dk7rtd|jd|ddt |}|j}n|St|}d }|D]2}t|ts|j|d k(s'|d|_d }4|j#|s!|d k(rd nd} td|dd|d| d|S)N)r2rzFTools can provide a dict in Command.update only when using dict with 'z' key as ToolNode input, got: z for tool 'rY'r0zpTools can provide a list of messages in Command.update only when using list of messages as ToolNode input, got: FrTr2z]`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)r.updater2rDrkrrr/rr3r0rrrrYr) rJrrrupdated_command state_updatemessages_updatehas_matching_tool_messagerexample_updates r8rzToolNode._validate_tool_command2s gnnd +!77 \]a]n]n\op#NN+;tF|nAG 'w/OS#X0F0FGM2L*..t/@/@"EO  -V# #NN+;tF|nAG 'w/O-44ON.o>$)!& 1Gg{3##tDz1#F| ,0)  1  (1J'pf  VW[\bWcVddlm|l}~BBPAQQRT  rG))__name__ __module__ __qualname____doc__rYr/__annotations__r r rrr r0r>r?r,r5rorr2rrrr!rprqrrr"rrrrr r~rrrrr __classcell__)rys@r8rfrfsZ?BD# $( &Gh012G G tCy! G " #xS)5i#1E+F F GG G0?   cN   ?? "? ?*?   cN   ?? "? ?$* k"* 89*  eGT+.S${:K5K0LLM N * X55895 5  5n66896 6  6p!&   cN   !& "!& tH~w'CDD E!&F  Xk5J ++   cN   + +Z!*29*= &$$   cN   $ "$ $B66689 6  6rGrfstaterk)rg__end__ct|tr|d}nMt|tr|j|gx}r|d}n#t ||gx}r|d}nt d|t |drt|jdkDryy)aGUse in the conditional_edge to route to the ToolNode if the last message has tool calls. Otherwise, route to the end. Args: state (Union[list[AnyMessage], dict[str, Any], BaseModel]): The state to check for tool calls. Must have a list of messages (MessageGraph) or have the "messages" key (StateGraph). Returns: The next node to route to. Examples: Create a custom ReAct-style agent with tools. ```pycon >>> from langchain_anthropic import ChatAnthropic >>> from langchain_core.tools import tool ... >>> from langgraph.graph import StateGraph >>> from langgraph.prebuilt import ToolNode, tools_condition >>> from langgraph.graph.message import add_messages ... >>> from typing import Annotated >>> from typing_extensions import TypedDict ... >>> @tool >>> def divide(a: float, b: float) -> int: ... """Return a / b.""" ... return a / b ... >>> llm = ChatAnthropic(model="claude-3-haiku-20240307") >>> tools = [divide] ... >>> class State(TypedDict): ... messages: Annotated[list, add_messages] >>> >>> graph_builder = StateGraph(State) >>> graph_builder.add_node("tools", ToolNode(tools)) >>> graph_builder.add_node("chatbot", lambda state: {"messages":llm.bind_tools(tools).invoke(state['messages'])}) >>> graph_builder.add_edge("tools", "chatbot") >>> graph_builder.add_conditional_edges( ... "chatbot", tools_condition ... ) >>> graph_builder.set_entry_point("chatbot") >>> graph = graph_builder.compile() >>> graph.invoke({"messages": {"role": "user", "content": "What's 329993 divided by 13662?"}}) ``` rz/No messages found in input state to tool_edge: rrrgr) r.r0r2r3rrDhasattrrZr)rrk ai_messagerhs r8tools_conditionrksl%2Y E4 %))L"2M&Mh&Mb\ UL"5 5 5b\ J5'RSSz<(S1F1F-G!-K rGc(eZdZdZddeeddfdZy) InjectedStateaAnnotation for a Tool arg that is meant to be populated with the graph state. Any Tool argument annotated with InjectedState will be hidden from a tool-calling model, so that the model doesn't attempt to generate the argument. If using ToolNode, the appropriate graph state field will be automatically injected into the model-generated tool args. Args: field: The key from state to insert. If None, the entire state is expected to be passed in. Example: ```python from typing import List from typing_extensions import Annotated, TypedDict from langchain_core.messages import BaseMessage, AIMessage from langchain_core.tools import tool from langgraph.prebuilt import InjectedState, ToolNode 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) ``` ```pycon [ ToolMessage(content='not enough messages', name='state_tool', tool_call_id='1'), ToolMessage(content='bar2', name='foo_tool', tool_call_id='2') ] ``` Nfieldr&c||_yrO)r)rJrs r8rozInjectedState.__init__s  rGrO)rrrrr r/rorrGr8rrs8thsmtrGrceZdZdZy) InjectedStoreaAnnotation for a Tool arg that is meant to be populated with LangGraph store. Any Tool argument annotated with InjectedStore will be hidden from a tool-calling model, so that the model doesn't attempt to generate the argument. If using ToolNode, the appropriate store field will be automatically injected into the model-generated tool args. Note: if a graph is compiled with a store object, the store will be automatically propagated to the tools with InjectedStore args when using ToolNode. !!! Warning `InjectedStore` annotation requires `langchain-core >= 0.3.8` Example: ```python from typing import Any from typing_extensions import Annotated from langchain_core.messages import AIMessage from langchain_core.tools import tool from langgraph.store.memory import InMemoryStore from langgraph.prebuilt import InjectedStore, ToolNode store = InMemoryStore() store.put(("values",), "foo", {"bar": 2}) @tool def store_tool(x: int, my_store: Annotated[Any, InjectedStore()]) -> str: '''Do something with store.''' stored_value = my_store.get(("values",), "foo").value["bar"] return stored_value + x node = ToolNode([store_tool]) tool_call = {"name": "store_tool", "args": {"x": 1}, "id": "1", "type": "tool_call"} state = { "messages": [AIMessage("", tool_calls=[tool_call])], } node.invoke(state, store=store) ``` ```pycon { "messages": [ ToolMessage(content='3', name='store_tool', tool_call_id='1'), ] } ``` N)rrrrrrGr8rrs1rGrtype_arginjection_typect|st|tr t|ryt|}|tus|t urt fdt|DSy)NTc36K|]}t|ywrO) _is_injection)rQtars r8rSz _is_injection..+sR=^4RsF)r.r,rPrr rrr)rrorigin_s ` r8rr"sW(N+8T"z(N'K"G%7i/Rx?QRRR rGrc|j}i}t|jD]\}}t|Dcgc]}t |t r|}}t |dkDrtd|d|dt |dk(r7|d}t|t r|jr|j||<d||<|Scc}w)NrMzXA tool argument should not be annotated with InjectedState more than once. Received arg  with annotations rr) get_input_schemarrrrrrZrDr.r)r full_schematool_args_to_state_fieldsrYtype_r injections injections r8rvrv/s'')K&(4[AGGI e%UO X}5   z?Q &&*V+=j\L _ !"1 I)]3 2;//)$/26)$/ %& %$% sCc&|j}t|jD]`\}}t|Dcgc]}t |t r|}}t |dkDrtd|d|dOt |dk(r|cSbycc}w)NrMzXA tool argument should not be annotated with InjectedStore more than once. Received arg rr)rrrrrrrZrD)rrrYrrrs r8rwrwIs'')K4[AGGI e%UO X}5   z?Q  &&*V+=j\L _ !K   sB)rh)FrrUr+rr dataclassesrtypingrrrr r r r r rrlangchain_core.messagesrrrrrlangchain_core.runnablesrlangchain_core.runnables.configrrlangchain_core.toolsrrrrulangchain_core.tools.baserpydanticrtyping_extensionsrrrlanggraph.errorsr langgraph.store.baser!langgraph.typesr"r#langgraph.utils.runnabler$rr@r/r0r2r9r5r>r?r,rFrdrfrrrrrvrwrrGr8rs    4;4C==**)5S!HsuS$t*_'=*   c d9os"# %  0$(38"4$tIPS?S9T$NddR#@ j!4S>9< =@@  @F<O<~2O2j  #(m)Q)Q#R   %(%tC#,>'?%4hsmrG