tj' tddlmZddlZddlZddlZddlZddlmZddlm Z m Z m Z m Z ddl mZmZddlmZddlmZddlmZmZmZmZdd lmZdd lmZdd lmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$dd l%m&Z&m'Z'dd l(m)Z)ddl*m+Z+ddl,m-Z-ddl.m/Z/m0Z0ddl1m2Z2m3Z3m4Z4m5Z5m6Z6ddl7m8Z8ddl9m:Z:m;Z;mm?Z?m@Z@mAZAddlBmCZCddlDmEZEddlFmGZGddlHmIZImJZJmKZKddlLmMZMddlNmOZOddlPmQZQddlRmSZSddlTmUZUmVZVddlWmXZXmYZYddlZm[Z[m\Z\m]Z]dd l^m_Z_m`Z`maZambZbdd!lcmdZddd"lemfZfmgZgdd#lhmiZimjZjdd$lkmlZldd%lmmnZnmoZodd&lpmqZqmrZrmsZsdd'ltmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|dd(l}m~Z~mZmZmZmZdd)lmZmZd*ZejeZd+Zd,Zed-.Gd/d0Zdmd5Zdnd9ZGd:d;eee~eefZGd<d=elee~eefeee~eefZdodBZedCZdpdGZdqdKZdrdOZdsdQZdtdTZe$dudZZe$d-d[dvd^Zd-d[dwd`ZdxdcZdydeZdzdgZd{dlZdS)|) annotationsN) defaultdict) AwaitableCallableHashableSequence) dataclass is_dataclass) timedelta)partial)isclass isfunctionismethod signature) FunctionType)NoneType) AnyGenericLiteralTypeVarUnioncastget_args get_originget_type_hintsoverload)RunnableRunnableConfig) BaseCache) Checkpoint) BaseStore) BaseModel TypeAdapter) NotRequiredRequiredSelfUnpack is_typeddict)_serde) INTERRUPTNS_ENDNS_SEPTASKS)get_cached_annotated_keysget_field_defaultget_update_as_tuples) create_model)coerce_to_runnable)coerce_timeout_policy) EMPTY_SEQMISSINGDeprecatedKwargs) BaseChannel)BinaryOperatorAggregate) DeltaChannel)EphemeralValue) LastValueLastValueAfterFinish)NamedBarrierValueNamedBarrierValueAfterFinish)ENDSTART TAG_HIDDEN) ErrorCodeInvalidUpdateError ParentCommandcreate_error_message) BranchSpec) StateNode StateNodeSpec)ManagedValueSpecis_managed_value)Pregel) ChannelRead PregelNode) ChannelWriteChannelWriteEntryChannelWriteTupleEntry)All CachePolicy CheckpointerCommand RetryPolicySend TimeoutPolicyensure_valid_checkpointer)ContextTInputT NodeInputTOutputTStateT)LangGraphDeprecatedSinceV05LangGraphDeprecatedSinceV10) StateGraphCompiledStateGraphz branch:to:{}__default_error_handler__T)slotscLeZdZUdZdZded<dZded<dZded<dZd ed <dS) _NodeDefaultsz$t**>>???@s *Ac eZdZUdZded<ded<ded<ded <d ed <d ed <ded<ded<ded<ded<ded<ded< dmddddnd"Zddddd#dod-Zedpd.Zdqdrd3Z e d4dddddddd5dsd=Z e d4ddddddd>dtd@Z e d4dddddddd5dudCZ e dmd4ddddddd>dvdFZ dmd4dddddddd5dwdHZ dxdLZ dmdydRZ dzdTZd{dVZ dmd|dWZd{dXZdmd}d[Z dmddddd4ddd\d~dlZdS)r`a A graph whose nodes communicate by reading and writing to a shared state. The signature of each node is `State -> Partial`. Each state key can optionally be annotated with a reducer function that will be used to aggregate the values of that key received from multiple nodes. The signature of a reducer function is `(Value, Value) -> Value`. !!! warning `StateGraph` is a builder class and cannot be used directly for execution. You must first call `.compile()` to create an executable graph that supports methods like `invoke()`, `stream()`, `astream()`, and `ainvoke()`. See the `CompiledStateGraph` documentation for more details. Args: state_schema: The schema class that defines the state. context_schema: The schema class that defines the runtime context. Use this to expose immutable context data to your nodes, like `user_id`, `db_conn`, etc. input_schema: The schema class that defines the input to the graph. output_schema: The schema class that defines the output from the graph. !!! warning "`config_schema` Deprecated" The `config_schema` parameter is deprecated in v0.6.0 and support will be removed in v2.0.0. Please use `context_schema` instead to specify the schema for run-scoped context. Example: ```python from langchain_core.runnables import RunnableConfig from typing_extensions import Annotated, TypedDict from langgraph.checkpoint.memory import InMemorySaver from langgraph.graph import StateGraph from langgraph.runtime import Runtime def reducer(a: list, b: int | None) -> list: if b is not None: return a + [b] return a class State(TypedDict): x: Annotated[list, reducer] class Context(TypedDict): r: float graph = StateGraph(state_schema=State, context_schema=Context) def node(state: State, runtime: Runtime[Context]) -> dict: r = runtime.context.get("r", 1.0) x = state["x"][-1] next_value = x * r * (1 - x) return {"x": next_value} graph.add_node("A", node) graph.set_entry_point("A") graph.set_finish_point("A") compiled = graph.compile() step1 = compiled.invoke({"x": 0.5}, context={"r": 3.0}) # {'x': [0.5, 0.75]} ``` set[tuple[str, str]]edgesz'dict[str, StateNodeSpec[Any, ContextT]]nodesz'defaultdict[str, dict[str, BranchSpec]]brancheszdict[str, BaseChannel]channelszdict[str, ManagedValueSpec]managedz:dict[type[Any], dict[str, BaseChannel | ManagedValueSpec]]schemasz set[tuple[tuple[str, ...], str]] waiting_edgesboolcompiled type[StateT] state_schematype[ContextT] | Nonecontext_schemaz type[InputT] input_schemaz type[OutputT] output_schemaN)rrtype[InputT] | Nonetype[OutputT] | NonekwargsUnpack[DeprecatedKwargs]rvrwc |dtx}tur>tjdtd| t t t|}|dtx}tur>tjdtd| t t t|}|dtx}tur>tjdtd| t t t|}i|_ t|_ tt|_i|_i|_i|_d |_t|_||_t t t|p||_t t t|p||_||_t5|_||j||jd ||jd dS) N config_schemazW`config_schema` is deprecated and will be removed. Please use `context_schema` instead.)category stacklevelinputM`input` is deprecated and will be removed. Please use `input_schema` instead.outputzO`output` is deprecated and will be removed. Please use `output_schema` instead.F allow_managed)getr5r|r}r_rrzrYr^rZr\rsetrrdictrrrrrrrrrrre_node_defaults _add_schema) selfrrrrrrinput_rs rs__init__zStateGraph.__init__s$ZZAA AM' Q Q Mi4     %!%d8nm!D!Djj'22 2F7 B B M_4     ##DL&99 jj733 3FG C C Ma4     $ $T']F ; ;  UU #D))      UU( f|/K|LL!$w-1N,OO,-:__ *+++ *%@@@ +5AAAAArr)rgrirjrkrgrfrirhrjStateNode[Any, ContextT] | Nonerk(float | timedelta | TimeoutPolicy | Noner&cv|j}|||_|||_|||_|t ||_|S)aMSet default node policies that apply to every node in this graph. Per-node values passed to `add_node` always take precedence over these defaults. Defaults are applied at `compile()` time. Policies set here are **not** inherited by subgraphs. `retry_policy` and `timeout` defaults apply to **all** nodes, including error-handler nodes. `cache_policy` and `error_handler` defaults only apply to regular nodes -- caching error-handler results is unsafe, and handlers must never catch themselves. Args: retry_policy: Default retry policy for nodes that don't specify their own via `add_node(..., retry_policy=...)`. Also applies to error-handler nodes. cache_policy: Default cache policy for nodes that don't specify their own via `add_node(..., cache_policy=...)`. Does **not** apply to error-handler nodes. error_handler: Default error handler invoked when any regular node raises and does not have its own `error_handler` set via `add_node`. The handler is **not** invoked when an error-handler node itself raises -- handler failures fail the run. timeout: Default timeout policy for nodes that don't specify their own via `add_node(..., timeout=...)`. Also applies to error-handler nodes. Accepts a `TimeoutPolicy`, a number of seconds (`float`), or a `timedelta`. Returns: Self: The builder instance, for chaining. Example: ```python graph = ( StateGraph(State) .set_node_defaults( retry_policy=RetryPolicy(max_attempts=3), error_handler=my_fallback_handler, ) .add_node("a", node_a) .add_node("b", node_b, retry_policy=custom_retry) # overrides default .add_edge(START, "a") .compile() ) ``` )rrgrirjr3rk)rrgrirjrkdefaultss rsset_node_defaultszStateGraph.set_node_defaultssRl&  #$0H !  #$0H !  $%2H "  4W==H  rrc4|jd|jDzS)Nc&h|]\}}|D]}||fSrqrq).0startsendstarts rs z(StateGraph._all_edges..RsA   (VSF  CHUCL    rr)rr)rs rs _all_edgeszStateGraph._all_edgesPs0z  ,0,>     rrTrrt type[Any]cr||jvr*t|t|\}}}|r>|sdSdS) Nz, rlz%Invalid managed channels detected in z: z<. Managed channels are not permitted in Input/Output schema.z Channel 'z&' already exists with a different typezManaged value ') rr~ _get_channelsjoinr ValueErroritemsrryr;r) rrtrrr type_hintsnames schema_namekeychannels rsrzStateGraph._add_schemaVs  % % &v . . .,9&,A,A )Hgz }  '**%fj"==  RKRR5RRR$;h#:'#:DL ( 0 0 1 1 W$-''}S)W44%gy99 ", WC W W W## 5*1DM#&& '  0 0 W$,&&|C(G33(YcYYY4 )0DL%%; & %, 0 0rrF)defermetadatarrgrirj destinationsrkrStateNode[NodeInputT, ContextT]rrdict[str, Any] | Noner'dict[str, str] | tuple[str, ...] | Nonec dS)aAdd a new node to the `StateGraph`, input schema is inferred as the state schema. Will take the name of the function/runnable as the node name. Args: node: The function or runnable this node will run. defer: Whether to defer the execution of the node until the run is about to end. metadata: The metadata associated with the node. input_schema: The input schema for the node. (Default: the graph's state schema) retry_policy: The retry policy for the node. If a sequence is provided, the first matching policy will be applied. cache_policy: The cache policy for the node. destinations: Destinations that indicate where a node can route to. Useful for edgeless graphs with nodes that return `Command` objects. If a `dict` is provided, the keys will be used as the target node names and the values will be used as the labels for the edges. If a `tuple` is provided, the values will be used as the target node names. !!! warning This is only used for graph rendering and doesn't have any effect on the graph execution. Example: ```python from typing_extensions import TypedDict from langchain_core.runnables import RunnableConfig from langgraph.graph import START, StateGraph class State(TypedDict): x: int def my_node(state: State, config: RunnableConfig) -> State: return {"x": state["x"] + 1} builder = StateGraph(State) builder.add_node(my_node) # node name will be 'my_node' builder.add_edge(START, "my_node") graph = builder.compile() graph.invoke({"x": 1}) # {'x': 2} ``` Returns: Self: The instance of the `StateGraph`, allowing for method chaining. Nrq rrrrrrgrirjrrkrs rsadd_nodezStateGraph.add_nodev F rr)rrrgrirjrrktype[NodeInputT]c dS)aAdd a new node to the `StateGraph` where input schema is specified. Will take the name of the function/runnable as the node name. Args: node: The function or runnable this node will run. defer: Whether to defer the execution of the node until the run is about to end. metadata: The metadata associated with the node. input_schema: The input schema for the node. retry_policy: The retry policy for the node. If a sequence is provided, the first matching policy will be applied. cache_policy: The cache policy for the node. destinations: Destinations that indicate where a node can route to. Useful for edgeless graphs with nodes that return `Command` objects. If a `dict` is provided, the keys will be used as the target node names and the values will be used as the labels for the edges. If a `tuple` is provided, the values will be used as the target node names. !!! warning This is only used for graph rendering and doesn't have any effect on the graph execution. Example: ```python from typing_extensions import TypedDict from langchain_core.runnables import RunnableConfig from langgraph.graph import START, StateGraph class State(TypedDict): x: int class NodeInput(TypedDict): x: int def my_node(state: NodeInput, config: RunnableConfig) -> State: return {"x": state["x"] + 1} builder = StateGraph(State) builder.add_node(my_node, input_schema=NodeInput) # node name will be 'my_node' builder.add_edge(START, "my_node") graph = builder.compile() graph.invoke({"x": 1}) # {'x': 2} ``` Returns: Self: The instance of the `StateGraph`, allowing for method chaining. Nrqrs rsrzStateGraph.add_nodes N rrractionc dS)aAdd a new node to the `StateGraph`, input schema is inferred as the state schema. Args: node: The name of the node. action: The function or runnable this node will run. defer: Whether to defer the execution of the node until the run is about to end. metadata: The metadata associated with the node. input_schema: The input schema for the node. (Default: the graph's state schema) retry_policy: The retry policy for the node. If a sequence is provided, the first matching policy will be applied. cache_policy: The cache policy for the node. destinations: Destinations that indicate where a node can route to. Useful for edgeless graphs with nodes that return `Command` objects. If a `dict` is provided, the keys will be used as the target node names and the values will be used as the labels for the edges. If a `tuple` is provided, the values will be used as the target node names. !!! warning This is only used for graph rendering and doesn't have any effect on the graph execution. Example: ```python from typing_extensions import TypedDict from langchain_core.runnables import RunnableConfig from langgraph.graph import START, StateGraph class State(TypedDict): x: int def my_node(state: State, config: RunnableConfig) -> State: return {"x": state["x"] + 1} builder = StateGraph(State) builder.add_node("my_fair_node", my_node) builder.add_edge(START, "my_fair_node") graph = builder.compile() graph.invoke({"x": 1}) # {'x': 2} ``` Returns: Self: The instance of the `StateGraph`, allowing for method chaining. Nrq rrrrrrrgrirjrrkrs rsrzStateGraph.add_noderrr%str | StateNode[NodeInputT, ContextT]&StateNode[NodeInputT, ContextT] | Nonec dS)aAdd a new node to the `StateGraph`, input schema is specified. Args: node: The function or runnable this node will run. If a string is provided, it will be used as the node name, and action will be used as the function or runnable. action: The action associated with the node. Will be used as the node function or runnable if `node` is a string (node name). defer: Whether to defer the execution of the node until the run is about to end. metadata: The metadata associated with the node. input_schema: The input schema for the node. retry_policy: The retry policy for the node. If a sequence is provided, the first matching policy will be applied. cache_policy: The cache policy for the node. destinations: Destinations that indicate where a node can route to. Useful for edgeless graphs with nodes that return `Command` objects. If a `dict` is provided, the keys will be used as the target node names and the values will be used as the labels for the edges. If a `tuple` is provided, the values will be used as the target node names. !!! warning This is only used for graph rendering and doesn't have any effect on the graph execution. Example: ```python from typing_extensions import TypedDict from langchain_core.runnables import RunnableConfig from langgraph.graph import START, StateGraph class State(TypedDict): x: int class NodeInput(TypedDict): x: int def my_node(state: NodeInput, config: RunnableConfig) -> State: return {"x": state["x"] + 1} builder = StateGraph(State) builder.add_node("my_fair_node", my_node, input_schema=NodeInput) builder.add_edge(START, "my_fair_node") graph = builder.compile() graph.invoke({"x": 1}) # {'x': 2} ``` Returns: Self: The instance of the `StateGraph`, allowing for method chaining. Nrqrs rsrzStateGraph.add_nodeIs V rrtype[NodeInputT] | Nonec  | dtx} turtjdt|| }| dtx} tur@tjdt|#t t tdz| }t| } t|tsX|}t|tr| }nt|d|jj}|t!d|jrt$d t|tsF|}t tt|d t|dd}|t!d|t(||jvrt!d |d |t,ks |t.krt!d |d t0t2fD]}||vrt!d|dd}t4} t7|s.t9|st9t|ddrvt;t|dpt;|x}rG|t=t?tAj!t tD|j#$}||x}r&t|t rt;|r|}|dx}rtK|}|tLur2tO|}|D] }tK|}|tPur|}|}n!|tPurFtO|x}r5tK|dtRurtO|dx}r|}n#tTtVtXf$rYnwxYw| | }|p|p|j-}d}|`d|}||jvrt!d|dt]t^t`ftc||dd|ddd|j|<|Ct]tt`ftc||d||||||||  |j|<nz|1t]tc||d||||||||  |j|<nGt]tdt`ftc||d||j-||||||  |j|<|p|}||3||S)aR Add a new node to the `StateGraph`. Args: node: The function or runnable this node will run. If a string is provided, it will be used as the node name, and action will be used as the function or runnable. action: The action associated with the node. Will be used as the node function or runnable if `node` is a string (node name). defer: Whether to defer the execution of the node until the run is about to end. metadata: The metadata associated with the node. input_schema: The input schema for the node. (Default: the graph's state schema) retry_policy: The retry policy for the node. If a sequence is provided, the first matching policy will be applied. cache_policy: The cache policy for the node. error_handler: Optional node-level error handler callable for this node. destinations: Destinations that indicate where a node can route to. Useful for edgeless graphs with nodes that return `Command` objects. If a `dict` is provided, the keys will be used as the target node names and the values will be used as the labels for the edges. If a `tuple` is provided, the values will be used as the target node names. !!! warning This is only used for graph rendering and doesn't have any effect on the graph execution. timeout: Timeout for each node attempt. A number or `timedelta` is a hard wall-clock cap and is not refreshed. Use `TimeoutPolicy` to configure both a wall-clock `run_timeout` and an `idle_timeout` refreshed by progress signals. When exceeded, a [`NodeTimeoutError`][langgraph.errors.NodeTimeoutError] is raised and the retry policy (if any) decides whether to retry. Timeouts are supported only for async nodes; sync nodes cannot be safely cancelled in-process. Example: ```python from typing_extensions import TypedDict from langchain_core.runnables import RunnableConfig from langgraph.graph import START, StateGraph class State(TypedDict): x: int def my_node(state: State, config: RunnableConfig) -> State: return {"x": state["x"] + 1} builder = StateGraph(State) builder.add_node(my_node) # node name will be 'my_node' builder.add_edge(START, "my_node") graph = builder.compile() graph.invoke({"x": 1}) # {'x': 2} ``` Example: Customize the name: ```python builder = StateGraph(State) builder.add_node("my_fair_node", my_node) builder.add_edge(START, "my_fair_node") graph = builder.compile() graph.invoke({"x": 1}) # {'x': 2} ``` Returns: Self: The instance of the `StateGraph`, allowing for method chaining. retryzM`retry` is deprecated and will be removed. Please use `retry_policy` instead.)rNrrrlz6Node name must be provided if action is not a functionzjAdding a node to a graph that has already been compiled. This will not be reflected in the compiled graph.namezNode `z` already present.z` is reserved.'z?' is a reserved character and is not allowed in the node names.__call__rvr__error_handler__z#Auto-generated error handler node `` already exists.FrtraceTrrrgriis_error_handler)rrgrierror_handler_nodeendsrrk)4rr5r|r}r^rrzr[r3ryrrget_namerrrlrrloggerwarning RuntimeErrorrr?r@r,r+r4rrrnextiterinspectrr parameterskeysrrrrTr NameErrorr StopIterationrrHrrYr2r]r)rrrrrrrgrirjrrkrrr characterinferred_input_schemarhintsfirst_parameter_name input_hintrtn rtn_originrtn_argsarg arg_originrargsvalsresolved_input_schemahandler_node_names rsrzStateGraph.add_nodes3rZZ11 1E' A A M_4    #$ jj'22 2F7 B B M_4    ##D$4t$;VDD '00$$$ F&(++ N((vz63C3LMM| L =  NN:   $$$ FWVVWVZQU5V5VWWXXD| L >  4:  >d>>>?? ? 3;;$%--:d:::;; ; &)  ID   b bbb! !%1:* 6""' $F##' $GFJ==>>' $ ( (C(CDD*!&))* ' $ '+/#- $\6 : :(,,(&+YY/C%D%DDz?%j$77?N:1))H---3$!+CJ!U**#+C==#+&&C)3CJ)W44&)-7 % 5#g--&.smm3U.&uQx00G;;%-eAh%7%77T< $9m4    D   #D  F1 FT5F )-  $ :D : :  DJ.. ^:K^^^-:#x-,H"=7HPUVVV2!!!% ---DJ( )  #,Z-AB"6EBBB)))#4   DJt  # .,"6EBBB2))#4   DJt   -VX-=>"6EBBB!.))#4   DJt $<'<  #   \ * * * s F3OO.-O. start_keystr | list[str]end_keyc|jrtdt|tr|t krt d|tkrt dt|ds3|td|j Dvrt d|d|j ||f|S|D]8}|t krt d||j vrt d|d 9|tkrt d|t kr||j vrt d|d |j t||f|S) aAdd a directed edge from the start node (or list of start nodes) to the end node. When a single start node is provided, the graph will wait for that node to complete before executing the end node. When multiple start nodes are provided, the graph will wait for ALL of the start nodes to complete before executing the end node. Args: start_key: The key(s) of the start node(s) of the edge. end_key: The key of the end node of the edge. Raises: ValueError: If the start key is `'END'` or if the start key or end key is not present in the graph. Returns: Self: The instance of the `StateGraph`, allowing for method chaining. kAdding an edge to a graph that has already been compiled. This will not be reflected in the compiled graph.zEND cannot be a start nodezSTART cannot be an end noderc3 K|] \}}|V dSNrq)rr_s rs z&StateGraph.add_edge..s?BB"%BBBBBBrrzAlready found path for node 'zB'. For multiple edges, use StateGraph with an Annotated state key.zNeed to add_node `z` first)rrrryrr?rr@hasattrrraddrrtuple)rrrrs rsadd_edgezStateGraph.add_edges" =  NN:    i % % C !=>>>% !>???4,, cBB&*jBBB??22!VIVVV JNNIw/ 0 0 0K F FE|| !=>>>DJ&& !De!D!D!DEEE' e  :;; ; c>>gTZ77B'BBBCC C i 0 0':;;; rrsourcepathCallable[..., Hashable | Sequence[Hashable]] | Callable[..., Awaitable[Hashable | Sequence[Hashable]]] | Runnable[Any, Hashable | Sequence[Hashable]]path_map&dict[Hashable, str] | list[str] | Nonecx|jrtdt|dd}|jpd}||j|vrt d|jd|dtj||d|j||<|j||j x}r| ||S) aAdd a conditional edge from the starting node to any number of destination nodes. Args: source: The starting node. This conditional edge will run when exiting this node. path: The callable that determines the next node or nodes. If not specifying `path_map` it should return one or more nodes. If it returns `'END'`, the graph will stop execution. path_map: Optional mapping of paths to node names. If omitted the paths returned by `path` should be node names. Returns: Self: The instance of the graph, allowing for method chaining. !!! warning Without type hints on the `path` function's return value (e.g., `-> Literal["foo", "__end__"]:`) or a path_map, the graph visualization assumes the edge could transition to any node in the graph. rNTr conditionzBranch with name `z` already exists for node ``) rrrr2rrrrF from_pathrr)rrrrrrts rsadd_conditional_edgesz StateGraph.add_conditional_edgess< =  NN:    "$T>>>y'K 4=( ( (TTYTT6TTT '1&:44&P&P fd#]6*40= =6 %   V $ $ $ rrWSequence[StateNode[NodeInputT, ContextT] | tuple[str, StateNode[NodeInputT, ContextT]]]cjt|dkrtdd}|D]}t|trt|dkr|\}}nt |}||jvrtd|d||||||||}|S)aAdd a sequence of nodes that will be executed in the provided order. Args: nodes: A sequence of `StateNode` (callables that accept a `state` arg) or `(name, StateNode)` tuples. If no names are provided, the name will be inferred from the node object (e.g. a `Runnable` or a `Callable` name). Each node will be executed in the order provided. Raises: ValueError: If the sequence is empty. ValueError: If the sequence contains duplicate node names. Returns: Self: The instance of the `StateGraph`, allowing for method chaining. z$Sequence requires at least one node.Nrz/Node names must be unique: node with the name 'z' already exists. If you need to use two different runnables/callables with the same name (for example, using `lambda`), please provide them as tuples (name, runnable/callable).)lenrryr rrrr )rr previous_namerrs rs add_sequencezStateGraph.add_sequences. u::>>CDD D$(  ! !D$&& ,3t99>>! dd%d++tz!! vdvvv MM$ % % %( mT222 MM rrrc8|t|S)a+Specifies the first node to be called in the graph. Equivalent to calling `add_edge(START, key)`. Parameters: key (str): The key of the node to set as the entry point. Returns: Self: The instance of the graph, allowing for method chaining. )r r@rrs rsset_entry_pointzStateGraph.set_entry_point*s}}UC(((rrc:|t||S)a Sets a conditional entry point in the graph. Args: path: The callable that determines the next node or nodes. If not specifying `path_map` it should return one or more nodes. If it returns END, the graph will stop execution. path_map: Optional mapping of paths to node names. If omitted the paths returned by `path` should be node names. Returns: Self: The instance of the graph, allowing for method chaining. )rr@)rrrs rsset_conditional_entry_pointz&StateGraph.set_conditional_entry_point7s,))%x@@@rrc8||tS)a0Marks a node as a finish point of the graph. If the graph reaches this node, it will cease execution. Parameters: key (str): The key of the node to set as the finish point. Returns: Self: The instance of the graph, allowing for method chaining. )r r?rs rsset_finish_pointzStateGraph.set_finish_pointOs}}S#&&&rr interruptSequence[str] | Nonec d|jD}|jD]\}}|||jD]!\}}|jr||"|D])}||jvr|t krtd|d*t |vrtdd|jD}|jD]\}}|D]\} } | j_| jD]D} | |jvr$| tkrtd|d| d| d|| Ek|t|jD]} | |kr|| |jD]&\}}|jr| |j'|D])} | |jvr| tkrtd | d *|r!|D]} | |jvrtd | d d |_ |S)Nch|]\}}|Srqrq)rsrcrs rsrz&StateGraph.validate..^s999vsAs999rrz%Found edge starting at unknown node 'rzOGraph must have an entrypoint: add at least one edge from START to another nodech|]\}}|Srqrq)rrrs rsrz&StateGraph.validate..os999vq#s999rrzAt 'z ' node, 'z' branch found unknown target 'z#Found edge ending at unknown node `rzInterrupt node `z ` not foundT) rrrr rrr@rvaluesr?updater)rr% all_sourcesrrrspecr all_targetscondbranchrrtargets rsvalidatezStateGraph.validate\s99999 #}2244 # #OE8 OOE " " " "***,, & &JD$y &%%%! T TFTZ''FeOO !R!R!R!RSSS  # #a  :9999 #}2244 2 2OE8 ( 0 0 2 2 f;*%{1133--dj00SCZZ", bu b bt b b\_ b b b##$,,,, - OOC((( $ 225=='OOD1112 2***,, . .JD$y .""49---! R RFTZ''FcMM !Pv!P!P!PQQQ  K! K Ktz))$%I%I%I%IJJJ*  rr)cachestoreinterrupt_beforeinterrupt_afterdebugr transformers checkpointerrSr4BaseCache | Noner5BaseStore | Noner6All | list[str] | Noner7r8r str | Noner91Sequence[Callable[[tuple[str, ...]], Any]] | None5CompiledStateGraph[StateT, ContextT, InputT, OutputT]c b t|}d} tjr|j|j|jg} |j| |j|j D]} | | j|j D]:} | D]#} | j| | j$;tj | |j } tj || }|pg}|pg}||dkr |dkr|ng|zngt|j|jdkrd|j|jvrdn-d|j|jD}t|j dkr d|j vrdn"d|j D}|j}d}|jvt(|jvrt+d t(d t(}t-t.t0ft3|j|d d|jddd |j|<|j D]n}|js||j||_|j|j |j|_|js|j|j |j|_|j|j |j|_od|jD}t?t@t0tBtDfd%id|did|jdidi|j |j#tHtK|jidtHddd|d|d|d|d|dd d|d|d |d!|d"|pd#d$|}| |_&|'tHd|jD]\}} |'|| tQtS|tTrtU|n|g|j|_+tQtS|tTrtU|n|g|j|_,|j-D]\}}|.|||j/D]\}}|.|||j D]6\}} | D]\}} |0||| 7|S)&a@Compiles the `StateGraph` into a `CompiledStateGraph` object. The compiled graph implements the `Runnable` interface and can be invoked, streamed, batched, and run asynchronously. Args: checkpointer: A checkpoint saver object or flag. If provided, this `Checkpointer` serves as a fully versioned "short-term memory" for the graph, allowing it to be paused, resumed, and replayed from any point. If `None`, it may inherit the parent graph's checkpointer when used as a subgraph. If `False`, it will not use or inherit any checkpointer. **Important**: When a checkpointer is enabled, you should pass a `thread_id` in the config when invoking the graph: ```python config = {"configurable": {"thread_id": "my-thread"}} graph.invoke(inputs, config) ``` The `thread_id` is the key used to store and retrieve checkpoints. Use a unique ID for independent runs, or reuse the same ID to accumulate state across invocations (e.g., for conversation memory). interrupt_before: An optional list of node names to interrupt before. interrupt_after: An optional list of node names to interrupt after. debug: A flag indicating whether to enable debug mode. name: The name to use for the compiled graph. transformers: Optional sequence of `StreamTransformer` classes or configured factories. Classes and factories are instantiated per run whenever `stream_events(version="v3")` / `astream_events(version="v3")` is called and are propagated to subgraph scopes. Custom factories should follow the standard `StreamTransformer` constructor shape by accepting `scope` as their first argument. Appended after the built-in stream transformers. Returns: CompiledStateGraph: The compiled `StateGraph`. N)rr*)r%r__root__c6g|]\}}t||SrqrJrrvals rs z&StateGraph.compile..s:C',,rrc6g|]\}}t||SrqrErFs rsrHz&StateGraph.compile..s; SAQRUAVAVrrz+Auto-generated default error handler node `rFrTrc@i|]\}}|js|j||jSr)rr)r node_namer.s rs z&StateGraph.compile../sA" " "  4(" .2-D-P t.-P-P-Prrbuilderschema_to_mapperrrrinput_channels stream_modeupdatesoutput_channelsstream_channelsr:interrupt_before_nodesinterrupt_after_nodes auto_validater8r5r4node_error_handler_mapr LangGraphstream_transformersrq)1rXr)STRICT_MSGPACK_ENABLEDrrrrappendrr+rbuild_serde_allowlistrapply_checkpointer_allowlistr3rrrrrj_DEFAULT_ERROR_HANDLER_NODErrHrrYr2rrrgrirkrar]rZr\rr@r:_serde_allowlist attach_node _pick_mapperrylist_output_mapper _state_mapperr attach_edger attach_branch)rr:r4r5r6r7r8rr9serde_allowlist schema_typesrrr1rRrSrdefault_handler_namer.rWrrrrrs rscompilezStateGraph.compilesl1>> 7;  ( !!"-L ".##D$7888 ))++ 7 7##D$56666 M0022 A A&oo//AAF*6$++F,?@@@A%:$O">oL ,1r)/R #c))&6%<%<!!"WW    4< 234499dl4+=>>> J $ T-? @ F F H H 4=!!Q&&:+F+F J$(M$7$7$9$9 &+/  ! -*dj88 G3GGG$? /'$0T5F5N$,$9! ) :)5%-$,$9!+ 0D'/ " " #':#3#3#5#5" " "  &fh&GH   D R  .. "  -,~d&788  !5 "  ,O ,O & $4#3 #2/! " %# $%% &%' (%) *$:#9+ ,$- .!- / 2%4!UD)))))++ , ,IC  d + + + +#//400 #D ! ! !!"   # #  "./400 #D ! ! !!"   " " * - -JE3   , , , ,- . .KFC   - - - -#}2244 < r9r?rvr@)rlrmrnrorprrpropertyrrrrr rrr r"r$r3rjrqrrrsr`r`sDDL 22225555$$$$((((GGGG3333NNN))))    156B -1.2 6B6B6B6B6B6BvDH+/9=<@ ??????B   X 00000@ *.!CG+/9=@D<@B B B B B XB H *.CG+/9=@D<@F F F F F XF P *.!CG+/9=@D<@B B B B B XB H:>J *.CG+/9=@D<@J J J J J XJ ^:>{ *.04CG+/9=@D<@{{{{{{z4444x<@ 00000d----^ ) ) ) )$<@ AAAAA0 ' ' ' '.....d&*`##'"&3726JN`#`#`#`#`#`#`#`#rrr`ceZdZUded<ded<ded<ded<d(fd Z d)d*dZ d)d*dZd+dZd,dZddd-d$Z d.fd' Z xZ S)/ra-StateGraph[StateT, ContextT, InputT, OutputT]rM,dict[type[Any], Callable[[Any], Any] | None]rNCallable[[Any], Any] | Nonercrdrrrvrwc Vtjdi|||_||_dSNrq)superrrMrN)rrMrNrrs rsrzCompiledStateGraph.__init__xs7 ""6""" 0rrNconfigRunnableConfig | Nonedict[str, Any]ct|jj|jj|jj|dS)NInputtyprrr)_get_json_schemarMrrrrrrss rsget_input_jsonschemaz'CompiledStateGraph.get_input_jsonschemasB  )L(\*w''     rrct|jj|jj|jj|dS)NOutputrx)rzrMrrrrr{s rsget_output_jsonschemaz(CompiledStateGraph.get_output_jsonschemasB  *L(\*x((     rrrrr#StateNodeSpec[Any, ContextT] | Nonec  |tkr9d|jj|jjD nBt |jjd|jjDz d fd t dgkrtn tt||j t|j nd f}|tkr.s:Aq'**rrcg|]\}}|Srqrqrs rsrHz2CompiledStateGraph.attach_node..s)999a999rrrNone | dict | Anyrv Sequence[tuple[str, Any]] | NonecF|dSt|tr fd|DSt|tr7|jtjkrdSfd|DSt|ttfr|rtd|Drg}|D]}t|trJ|jtjkr-| fd|Da| |pd|St|x}rt|rt|Std|tj}t#|)Nc&g|] \}}|v ||fSrqrqrrr output_keyss rsrHzHCompiledStateGraph.attach_node.._get_updates..s+MMM41aA._get_updates..s2#q!ADTDTQFDTDTDTrrc3@K|]}t|tVdSrryrTris rsr zGCompiledStateGraph.attach_node.._get_updates..s,>>1 1g..>>>>>>rrc3.K|]\}}|v ||fVdSrrqrs rsr zGCompiledStateGraph.attach_node.._get_updates..s>'''+q![HXHXQFHXHXHXHX''rrrqzExpected dict, got )message error_code)ryrrrTgraphPARENT_update_as_tuplesrbr anyextendrzr.r0rErBINVALID_GRAPH_NODE_RETURN_VALUErC)rrQrtmsg _get_updatesrs rsrz4CompiledStateGraph.attach_node.._get_updatess}tE4(( .MMMM5;;==MMMME7++ .;'.004','>'>'@'@54-00 . .>>>>>>> . 24>>A!!W-->7gn44$''''/0/B/B/D/D''' ||A'<"====E{{"! .(A!(D(D .+E;???*9%99(H)---rrrC)mapper)rstatic)tagstriggersrwritersrF)guard) rrrrrrgrirrboundrk)rrrvr)#r@rMrrrrbrrrP _get_root_control_branchr_control_staticrMrArNrrrrNra_CHANNEL_BRANCH_TOformatrr<rr:rrgrirrrunnablerkr) rrr write_entriesrrOis_single_inputrbranch_channelrrs @@rsr`zCompiledStateGraph.attach_nodes %<< L01JKQQSSKK t|45599"l288::999K$ .$ .$ .$ .$ .$ .$ .P #$/J<$?$?yy\    #&# (='ty111     Q  %<<( \%m445 DJsOOO  04S4,,$,:SL!$,"6|"DEEN!.11Q6W:;WOt444.|<%nlCC6<%l3/66s;;N:6$S)))#Cu555 M. ) )()(7K**^%m445!.!.!%!6#'#:m DJsOOO" rrrstr | Sequence[str]rc t|trh|tkr[|j|jt tt |dfdSdS|tkrdd |d|}|j j|j r+ttt||j|<n*t!tt||j|<|j|j||D]E}|j|jt t||fDdSdS)Nzjoin:+:)ryrr?rrr[rNrOrrrrMrr>rrr=r)rrr channel_namers rsrezCompiledStateGraph.attach_edges~ fc " " czz 6"*11 *+=+D+DS+I+I4PPRz CZZ;388F#3#3;;c;;L|!#&, R.JV// l++/@S[[.Q.Q l+ JsO $ + +L 9 9 9   5!)00 "3L%"H"H!JKKZ  rrT) with_readerrrr1rFrrc d dd}|r|jp0||jjvr|jj|jn |jj}t |jj|}||jvr|j|}nt||}||j|<ttj |d gkr|d n|d | } nd} |j|j | || dS)NFpacketsSequence[str | Send]rrrv"Sequence[ChannelWriteEntry | Send]c,fd|D}|sgS|S)Ncg|]]}r n |tkt|ts5t|tkr|nt|dn|^S)TN)r?ryrVrOrr)rprs rsrHzHCompiledStateGraph.attach_branch..get_writes..!s   "  )*S &a..%#XX+=+D+DQ+G+G)1rrrq)rrwritess ` rs get_writesz4CompiledStateGraph.attach_branch..get_writessA    !   F  MrrrCrT)selectfreshr)F)rrrrrvr)rrMrrrbrrNrar rLdo_readrr[run) rrrr1rrrtrrreaders rsrfz CompiledStateGraph.attach_branchs.;@     $  (DL... "5)66\.  DL0899H....v6%h7706%f-=D#&.:,&>&>x{{H >>>FFF 5!((J)G)GHHHHHrr checkpointr ct||d}|d}|d}|sdS|ddkrdSt|D]}|dr|dd }||jvr>d |}||vr)t ||||n||}||i|tifD]>} || vr8| |} || vrt | | || |<9| | |<?||vr||vr||||<|||<t|D]4}|d r| ddkr|dd }||jvrXd |}||vr)t ||||n||}||i|tifD]>} || vr8| |} || vrt | | || |<9| | |<?||vr||vr||||<|||<6t|j |stt} |jjD]6\} } | t kr&| t"kr| | | 7t|D]-}|t kr||jvr||}||t&}| |D]} d | }||vrt |||n|}|| i|tifD]>} || vr8| |} || vrt | | || |<9| | |<?||vr|t&ur|||<|||<t|vr&|t|t&-dSdS) z+Migrate a checkpoint to new channel layout.channel_valueschannel_versions versions_seenNrzstart:rrz branch:to:zbranch:)rr_migrate_checkpointrb startswithsplitrmaxpoprr*countr isdisjointrrMrr@r?r[r5)rrr+versionsseenrrnew_knew_vssssource_to_targetrrrcrs rsrz&CompiledStateGraph._migrate_checkpointLs ##J///,-01/*  F c?a   Fh ( (A||H%% (wws||Atz))+T++((a999!a  88D"--txx 2/F/FG**BBwwFF1II B;;(+Ar%y(9(9BuII()BuI&&1;;$*JJqMMF5M"'h ( (A||I&& (1773<<1+<+<wws||B'tz))+T++((a999!a  88D"--txx 2/F/FG**BBwwFF1II B;;(+Ar%y(9(9BuII()BuI&&1;;$*JJqMMF5M"'4:))(33 8*400 "l0 8 8 sE>>cSjj$U+223777(^^ 8 8:: ?? QA 1g..A/200 2S 2 2;@H;L;LHUOQ 7 7 7RS#'88C#4#4dhhy"6M6M"N22B Bww$&FF1II#(B;;03Ar%y0A0ABuII01BuI ..1G3C3C,-F5M*/ D((Y++Aw777? 8 8  8 8rr)rMrmrNrnrrrvrwr)rsrtrvru)rrrrrvrw)rrrrrvrw) rrrrr1rFrrrvrw)rr rvrw) rlrmrnrprr|rr`rerfr __classcell__)rs@rsraraos.;:::BBBB////.... 1 1 1 1 1 1/3     /3     hhhhT6QU/I/I/I/I/I/Ibg8g8g8g8g8g8g8g8g8g8rrra state_keys Sequence[str]rroc|dgkrdSt|r9t|tst|rt t |SdS)NrC)r issubclassr"r r _coerce_state)rrts rsrarasYj\!!tv.Jvy99.\&=Q=Q.}f--- 4rr_Stype[_S]rruc|di|Srqrq)rtrs rsrrs 6??E??rrvaluerSequence[tuple[str, Any]]ct|tr t|ffSg}t|tr||nKt|t t fr/|D],}t|tr||-g}|D]}|jtjkrt|t|j ttfr|j gn|j }|D]}t|tr|t|f4t|tr:|tkr/|t|df|Sr)ryrVr-rTr[rbr rrrDgotorr?rr)rcommandscmdrcommand goto_targetsgos rsrrs%!   H%!!% ED%= ) )% % %C#w'' %$$$!#CBB =GN * *(( ()c{CC UW\NN  B BB"d## B E2;''''B$$ Bs .55b994@AAA  B Jrrr tuple[str, ...] | dict[str, str]%Sequence[tuple[str, Any, str | None]]ct|trd|DSd|DS)Nchg|]/\}}|tkr|nt|d|f0Srr?rr)rrlabels rsrHz#_control_static..sN   5s((QQ 2 9 9! < .sG   NO!s((QQ 2 9 9! <
|jtjkr-||U| d|fm|S|d|fgSdS)Nrqc3@K|]}t|tVdSrrrs rsr z_get_root..s,661 1g&&666666rrrC) ryrTrrrrbr rrr[)rrQrs rsrrs%!!% ;'. ( (2&&(((54-((% % 66666 6 6% *, 0 0A!W%% 07gn,,q22445555 A////  U#$$  rr type[dict]Jtuple[dict[str, BaseChannel], dict[str, ManagedValueSpec], dict[str, Any]]c(t|dsdtd|diiifSt|d}d|D}d|Dd |D|fS) NrprCFrT)include_extrascBi|]\}}|dk |t||S) __slots__) _get_channel)rrrys rsrLz!_get_channels..s= D# ;   l4%%   rrcDi|]\}}t|t||Srq)ryr7rs rsrLz!_get_channels..s-III$!QjK.H.HIAIIIrrc8i|]\}}t|||SrqrErs rsrLz!_get_channels..s,BBB$!Q.>q.A.ABABBBrr)r rrr)rtrall_keyss rsrr s 6, - - j&NNN O     t<<> +/+B*D   S:dK#@#@ Stgc<.H.HQCNNcRRRRR 4rrBinaryOperatorAggregate | Nonect|dr|j}t|dkrt|drt |d}t |j}td|Ddkrt||dStd|dS)Nrrrc3@K|]}|j|j|jfvVdSr)kindPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORD)rrs rsr z"_is_field_binop..isHFq0!2IJJrrrz5Invalid reducer signature. Expected (a, b) -> c. Got ) r rrcallablerrbrr+sumr8r)ryrsigparamss rsr r bssN## t99>>htBx00>DH%%C#.//1122F#  /sDH=== QCQQ 4rrManagedValueSpec | Nonec*t|drH|j}t|dkr.t|dp|d}t |r|St|+t |x}r|dx}rt ||SdS)Nrrrr)r rrrrJrr)rryr decorationargs inner_types rsrrwssN##" t99>>#DH--9bJ ++ "!! 3#c]] "T $7 "Z $'tZ888 4rrrzrrrc:tr)ttrSt r!t St|}t|dkrB|ddkr6t||dj dfSt|fd|DS)NrrrC)rootc i|]K}|vt|t!||jt||jfLSrq)ryr7 UpdateTyper/)rrrrys rsrLz$_get_json_schema..sl # # #H}}HQK)M)M}  .- ! ( 6 # %}}rr)field_definitions) r rr"model_json_schemar(r# json_schemarbrrr1r')ryrrrrs` ` rsrzrzs2 s||" 3 22"$$&&& c  "3++---GCL%%''(( t99>>d1g33tAw'2D9 !! "   # # # # #%S\ # # #  !!! "rr)rtrurvrw)rrrvr)rrrtrrvro)rtrrrurvr)rrrvr)rrrvr)rrrvr)rtrrvr)rrrrrrrvr7)rrrrrrrvr)rrrrrrrvr)ryrrvr )ryrrvr)rrryrrvr) ryrzrrrrrrrvru) __future__rrloggingr{r| collectionsrcollections.abcrrrr dataclassesr r datetimer functoolsr r rrrtypesrrrrrrrrrrrrlangchain_core.runnablesrrlanggraph.cache.baserlanggraph.checkpoint.baser langgraph.store.baser!pydanticr"r#typing_extensionsr$r%r&r'r(langgraph._internalr)langgraph._internal._constantsr*r+r,r-langgraph._internal._fieldsr.r/r0langgraph._internal._pydanticr1langgraph._internal._runnabler2langgraph._internal._timeoutr3langgraph._internal._typingr4r5r6langgraph.channels.baser7langgraph.channels.binopr8langgraph.channels.deltar9"langgraph.channels.ephemeral_valuer:langgraph.channels.last_valuer;r<&langgraph.channels.named_barrier_valuer=r>langgraph.constantsr?r@rAlanggraph.errorsrBrCrDrElanggraph.graph._branchrFlanggraph.graph._noderGrHlanggraph.managed.baserIrJlanggraph.pregelrKlanggraph.pregel._readrLrMlanggraph.pregel._writerNrOrPlanggraph.typesrQrRrSrTrUrVrWrXlanggraph.typingrYrZr[r\r]langgraph.warningsr^r___all__ getLoggerrlrrr^rer~rr`rararrrrrrrr r rrzrqrrrsrSs"""""" ######CCCCCCCCCCCC////////<<<<<<<<<<<<&&&&&&                        >=======******000000******++++++++OOOOOOOOOOOOOO&&&&&&  766666<<<<<<>>>>>>LLLLLLLLLL//////<<<<<<111111======IIIIIIII7666666666 /.....::::::::$#####::::::::                    KJJJJJJJJJJJJJWWWWWWWW .  8 $ $#9 ))))))))    @@@@j#j#j#j#j#67:;j#j#j#Z'D8D8D8D8D8 68VW ,- FHfg -.D8D8D8N  WT]]:     %%%%..    BF))))) ) :>48*&""""""""""""rr