(Gg &ddlZddlZddlZddlZddlmZddlmZddlmZm Z m Z m Z ddl m Z ddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZmZddl m!Z!ddl"m!Z#dd l$m%Z%dd l&m'Z'dd l(m)Z)dd l*m+Z+dd l,m-Z-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8m9Z9m:Z:m;Z;mZ>ddl?m@Z@mAZAmBZBmCZCddlDmEZEddlFmGZGmHZHmIZImJZJmKZKddlLmMZMddlNmOZOmPZPmQZQmRZRmSZSmTZTddlUmVZVmWZWddlXmYZYmZZZm[Z[ddl\m]Z]ddl^m_Z_m`Z`maZambZbddlcmdZdddlemfZfddlgmhZhmiZimjZjejelZmdeeeefd dfd!Znd"eid eofd#ZpGd$d%eZqGd&d'eJZrGd(d)eIZsd*erdeed eegeffd+Ztd,eeodeed-eeueoefd eeegeffd.Zvdeed/eueoefd eueoeffd0Zwd1ed eeeoeKffd2Zxd1ed eeeoeKffd3Zyehexeye>gd4d4d45ZzeEezdZ{deeud e|eueoe)feueoeRfeueoefffd6Z}ed7eod8ed9ed4d e)fd:Z~ed;d<d7eod8ed9ed;d ee)eRffd=Z~d;d<d7eod8ed9ed ee)eRffd>Z~d?eed ee)fd@Zd?eed ee+fdAZd7eod?eed eeRfdBZd?edCeudDeud7eod ee!f dEZdFZy)GN) defaultdict)partial)isclass isfunctionismethod signature) FunctionType)Any AwaitableCallableHashableLiteral NamedTupleOptionalSequenceTypeUnioncastget_args get_originget_type_hintsoverload)RunnableRunnableConfig) BaseModel)Self)LangGraphDeprecationWarning) BaseChannel)BinaryOperatorAggregate)DynamicBarrierValue WaitForNames)EphemeralValue) LastValue)NamedBarrierValue) Checkpoint) EMPTY_SEQ INTERRUPTMISSINGNS_ENDNS_SEPSELF TAG_HIDDEN) ErrorCodeInvalidUpdateError ParentCommandcreate_error_message)Branch)ENDSTART CompiledGraphGraphSend)SchemaCoercionMapper)ChannelKeyPlaceholderChannelTypePlaceholderConfiguredManagedValueManagedValueSpecis_managed_valueis_writable_managed_value) ChannelRead PregelNode) ChannelWriteChannelWriteEntryChannelWriteTupleEntry) BaseStore)All CheckpointerCommand RetryPolicy)get_field_default) create_model)RunnableCallable RunnableLikecoerce_to_runnableschemareturnct|trytj|ryt j d|dy)NzInvalid state_schema: z. Expected a type or Annotated[type, reducer]. Please provide a valid schema to ensure correct updates. See: https://langchain-ai.github.io/langgraph/reference/graphs/#stategraph) isinstancetypetypingrwarningswarn)rMs r/home/kushmeetdev/apache_webroot/langgraph_flaskproject/venv/lib/python3.12/site-packages/langgraph/graph/state.py_warn_invalid_state_schemarVWs=&$ v MM )V Vnodect|tr|jSt|r!t |d|j j Stdt|)N__name__zUnsupported node type: ) rPrget_namecallablegetattr __class__rZ TypeErrorrQ)rXs rU_get_node_namer`csO$!}} $tZ)@)@AA1$t*>??rWceZdZUeed<eeeefed<e eed<ee ed<e Z ee eedfeeeffed<y) StateNodeSpecrunnablemetadatainput retry_policy.endsN)rZ __module__ __qualname__r__annotations__rdictstrr rrGr&rgrtuplerWrUrbrblsYtCH~&& 9;''=FD(5sCx$sCx.89 :FrWrbceZdZUdZeeefed<eeefed<eee fed<ee e eee ee fffed< d/dddde e e d e e e d e e e d e e e d df fd Zed eeeeffdZd0dede e d dfdZeddddddede eee fd e e e de ede e eeefeedffd ef dZeddddddedede eee fd e e e de ede e eeefeedffd efdZ d1dddddde eefde ede eee fd e e e de ede e eeefeedffd efdZde eeefded effd Z d/ded e ede eeeffedee eeeffee e eeefffd!e e eeefeefd"e ed ef d#Z de!e eeeeffd efd$Z" d1dddd%dd&d'e#d(e e$d)e e e%eefd*e e e%eefd+ed,e ed d-fd.Z&xZ'S)2 StateGraphaA 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. Args: state_schema (Type[Any]): The schema class that defines the state. config_schema (Optional[Type[Any]]): The schema class that defines the configuration. Use this to expose configurable parameters in your API. Examples: >>> from langchain_core.runnables import RunnableConfig >>> from typing_extensions import Annotated, TypedDict >>> from langgraph.checkpoint.memory import MemorySaver >>> from langgraph.graph import StateGraph >>> >>> 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 ConfigSchema(TypedDict): ... r: float >>> >>> graph = StateGraph(State, config_schema=ConfigSchema) >>> >>> def node(state: State, config: RunnableConfig) -> dict: ... r = config["configurable"].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() >>> >>> print(compiled.config_specs) [ConfigurableFieldSpec(id='r', annotation=, name=None, description=None, default=None, is_shared=False, dependencies=None)] >>> >>> step1 = compiled.invoke({"x": 0.5}, {"configurable": {"r": 3.0}}) >>> print(step1) {'x': [0.5, 0.75]}nodeschannelsmanagedschemasN)reoutput state_schema config_schemarerurNct||.|| td|}tjdt dn||}||}i|_i|_i|_i|_ ||_ ||_ ||_ |j||j|d|j|d||_t|_y)Nz-Must provide state_schema or input and outputzInitializing StateGraph without state_schema is deprecated. Please pass in an explicit state_schema instead of just an input and output schema.) stacklevelF allow_managed)super__init__ ValueErrorrSrTrrtrrrs type_hintsrMreru _add_schemarwset waiting_edges)selfrvrwrerur^s rUr~zStateGraph.__init__s   } !PQQ L MMf+  }$~%   ;="    & e4 u5*?BurWc ~|j|jDchc]\}}|D]}||fc}}}zScc}}}wN)edgesr)rstartsendstarts rU _all_edgeszStateGraph._all_edgessPzz,0,>,>  (VSF CHUCL     s8 r|rMc||jvr0t|t|\}}}|r2|s0dj|}t |dd}t d|d|di|||j|<||j |<|jD]U\}} ||jvr3|j|| k7s't| tr8t d|d| |j|<W|jD]D\}}||jvr"|j||k7s't d |d||j|<Fyy) Nz, rZz%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 ') rtrV _get_channelsjoinr]rritemsrrrPr#rs) rrMr|rrrsrnames schema_namekeychannels rUrzStateGraph._add_schemasl  % &v .,9&,A )Hgz} '*%fj"=  ;K=5'RRR$;h#:'#:DLL &0DOOF # ( 0 1 W$--'}}S)W4%gy9 ","+C50V W#*1DMM#& 1!(  0 W$,,&||C(G3(-cU2XY)0DLL% 0/ &rW)rdreretry destinationsrXrdrr.cy)aAdds a new node to the state graph. Will take the name of the function/runnable as the node name. Args: node (RunnableLike): The function or runnable this node will run. Raises: ValueError: If the key is already being used as a state key. Returns: Self: The instance of the state graph, allowing for method chaining. Nrn)rrXrdrerrs rUadd_nodezStateGraph.add_nodes, rWactioncy)amAdds a new node to the state graph. Args: node (str): The key of the node. action (RunnableLike): The action associated with the node. Raises: ValueError: If the key is already being used as a state key. Returns: Self: The instance of the state graph, allowing for method chaining. Nrn)rrXrrdrerrs rUrzStateGraph.add_nodes. rWc t|tsQ|}t|tr|j}n!t |d|j j }| td||jvrtd|d|jrtjdt|ts5|}ttt |dt |dd}| td|t||jvrtd|d |tk(s |t k(rtd|d t"t$fD]#}|tt|vstd|d t&} t)|s"t+|st+t |d dr0t-t |d xs t-|x} r |}t/t1t3j4tt6|j8j;} | j=| x} rt| t>r t-| r| }| j=d x} rytA| } | tBur+tE| }|D]}tA|}|tFus|} |} n| tFur3tE| x}r&tA|dtHurtE|dx}r|}||}||jQ|tStU|tt|d||xs |jV|||jtt|<|S#tJtLtNf$rYwxYw)aAdds a new node to the state graph. Will take the name of the function/runnable as the node name. Args: node (Union[str, RunnableLike]): The function or runnable this node will run. action (Optional[RunnableLike]): The action associated with the node. (default: None) metadata (Optional[dict[str, Any]]): The metadata associated with the node. (default: None) input (Optional[Type[Any]]): The input schema for the node. (default: the graph's input schema) retry (Optional[RetryPolicy]): The policy for retrying the node. (default: None) destinations (Optional[Union[dict[str, str], tuple[str, ...]]]): Destinations that indicate where a node can route to. This is 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. NOTE: this is only used for graph rendering and doesn't have any effect on the graph execution. Raises: ValueError: If the key is already being used as a state key. Examples: ```pycon >>> from langgraph.graph import START, StateGraph ... >>> def my_node(state, config): ... return {"x": state["x"] + 1} ... >>> builder = StateGraph(dict) >>> 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} ``` Customize the name: ```pycon >>> builder = StateGraph(dict) >>> 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 state graph, allowing for method chaining. rZNz6Node name must be provided if action is not a function'z&' is already being used as a state keyzjAdding 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__rNrFrtrace)rerfrg),rPrlrr[r]r^rZrrrcompiledloggerwarningr RuntimeErrorrqr2r3r*r)r&rrrnextiterinspectrr parameterskeysgetrQrrrrFr NameErrorr_ StopIterationrrbrLrM)rrXrrdrerr characterrghintsfirst_parameter_name input_hintrtn rtn_originrtn_argsarg arg_originrargsvalss rUrzStateGraph.add_node(sEp$$F&(+(vz63C3C3L3LM| L 4== q&LMN N == NN: $$FWVVWVZQU5VWXD| L >  4:: vdV+=>? ? 3;$%-vdV>:; ; &) IDdO+  {"ab  8A* 6"F#GFJ=>' (CD*!&)**=+/#-- $\6 :(j,(&+YY/C%DDzD%j$7N:>DJJ& #5eWG!DEE  F e :; ; c>gTZZ71''BC C i 0':; rWsourcepathpath_mapthenc|jrtjdt|dd}|jxsd}||j |vrt d|jd|dtj|||d|j ||<|j ||jx}r|j||S) a0Add a conditional edge from the starting node to any number of destination nodes. Args: source (str): The starting node. This conditional edge will run when exiting this node. path (Union[Callable, Runnable]): 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[dict[Hashable, str]]): Optional mapping of paths to node names. If omitted the paths returned by `path` should be node names. then (Optional[str]): The name of a node to execute after the nodes selected by `path`. Returns: Self: The instance of the graph, allowing for method chaining. Note: Without typehints 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 ``) rrrrLrbranchesrr1 from_path input_schemar)rrrrrrrMs rUadd_conditional_edgesz StateGraph.add_conditional_edgess> == NN:  "$T>yy'K 4==( ($TYYK/NvhVWX '-&6&6tXtT&R fd#]]6*40== =6 =   V $ rWc2t|dkr tdd}|D]v}t|trt|dk(r|\}}n t |}||j vrtd|d|j ||||j|||}x|S)aAdd a sequence of nodes that will be executed in the provided order. Args: nodes: A sequence of RunnableLike objects (e.g. a LangChain Runnable or a callable) or (name, RunnableLike) 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 state graph, allowing for method chaining. z$Sequence requires at least one node.Nryz/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).)lenrrPrmr`rqrr)rrq previous_namerXrs rU add_sequencezStateGraph.add_sequences$ u:>CD D'+  !D$&3t9>! d%d+tzz! EdVLvv MM$ %( mT2 M! !$ rWF)storeinterrupt_beforeinterrupt_afterdebugr checkpointerrrrrrCompiledStateGraphc |xsg}|xsg}|j|dk7r |dk7r|ng|zngt|j|jdk(rd|j|jvrdnD|j|jj Dcgc]\}}t |s|c}}} t|j dk(rd|j vrdn8|j j Dcgc]\}}t |r|c}}} tdid|d|jdt|j dkDrAt|jr,t|jttfr |jndd id i|j |jtt!|jid td d d| d| d|d|d|ddd|d|d|xsd} | j#td|j$j D]\}} | j#|| | j'tt(t*d|j$j D]"\}} | j'|t(t*d$|j,D]\} }| j/| ||j0D]\}}| j/|||j2j D]0\} }|j D]\}}| j'| ||2| jScc}}wcc}}w)aCompiles the state graph into a `CompiledGraph` object. The compiled graph implements the `Runnable` interface and can be invoked, streamed, batched, and run asynchronously. Args: checkpointer (Optional[Union[Checkpointer, Literal[False]]]): 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. interrupt_before (Optional[Sequence[str]]): An optional list of node names to interrupt before. interrupt_after (Optional[Sequence[str]]): An optional list of node names to interrupt after. debug (bool): A flag indicating whether to enable debug mode. Returns: CompiledStateGraph: The compiled state graph. *) interruptr__root__builder config_type input_modelNrqrrinput_channels stream_modeupdatesoutput_channelsstream_channelsrinterrupt_before_nodesinterrupt_after_nodes auto_validateFrrr LangGraph with_readerrn)validaterrtrurr<rrrrwrre issubclassr BaseModelV1rsr3r" attach_noderq attach_branchr+CONTROL_BRANCHr attach_edgerr)rrrrrrrrvalrrrrXrrrrbranchs rUcompilezStateGraph.compileCs:,1r)/R #c)&6%<!"W  4<< ,-2dll4;;77  !% T[[ 9 ? ? AC', 4==!Q&:+F %)MM$7$7$9 SAQRUAV &  ** t}}%)DJJ'tzzI{+CD   --,,~djj1 !! ""# $,% &,' (&) *$4+ ,#2- . / 01 23 4$5 : UD)))+ ,IC  d + , udNN))+ QIC  " "3n% " P Q** -JE3   , - -- .KFC   - . $}}224 *  S "   $  uT#s(^U38_%DEF    . .2%)'+IM   4S>*  S "   $ uT#s(^U38_%DEF    6*.V .2%)'+IMVC%&V&V 4S>* V S " V $VuT#s(^U38_%DEFV Vp$%T#Y"7$#$$$\EI"11 S%$x. 899 : S)E(DN*B$CDD E S%$x. 899 : < 15hm!4d3i!?@A1sm1 1f(lE#|2C,DDEF( (X&*k#&*<@;?"k#"k# " k# #5d3i#89 k# "%T#Y"78 k#k#smk# k#rWrpc eZdZUeed< ddeedeefdZ ddeedeefdZ de dee ddfd Z d ee ee fd e ddfd Zd dde de dededdf dZdeddfdZy)rrNconfigrNct|jj|jj|jj|j dS)NInputtyprtrrr) _get_schemarrertrrr[rrs rUget_input_schemaz#CompiledStateGraph.get_input_schemasD ""LL((\\**w'   rWct|jj|jj|jj|j dS)NOutputr)rrrurtrrr[rs rUget_output_schemaz$CompiledStateGraph.get_output_schemasD ##LL((\\**x(   rWrrXc | |tk(rZ|jj|jjj Dcgc]\}}t |s|c}} nbt |jj|jjj Dcgc]\}}t|r|c}}z dtdtttttffd}dtdt tfdtttttff fd t# dgk(r|n f}|tk(r=t%t&gtgtgt)|t&gg|j*|<y||r |jn|jj,}|jj|Dcic]}||}}t/|d k(xrd|v} t0j3|} t5td |j| <t%| g| r t |n|t7t |||jj8|t)|t&gg|j:|j<|j> |j*|<yt@cc}}wcc}}wcc}w) NrerNct|tr.|jtjk(ry|j St|t t fr|r~td|Drlg}|D]c}t|tr>|jtjk(r1|j|j Q|jd|fe|S|d|fgSy)Nrnc3<K|]}t|tywrrPrF.0is rU zDCompiledStateGraph.attach_node.._get_root..>1 1g.>r) rPrFgraphPARENT_update_as_tuplesrrmanyextendappend)rerrs rU _get_rootz1CompiledStateGraph.attach_node.._get_roots%);;'..0..0054-0>>>138A!!W-77gnn4$q':':'<= A7 8"#U+,,#rWc$|yt|tr*|jDcgc]\}}| vs ||fc}}St|trH|jtj k(ry|j Dcgc]\}}| vs ||fc}}St|ttfr|rtd|Dr}g}|D]t}t|trG|jtj k(r1|j fd|j DZ|j |xsdv|St|x}rt|rt|trD|j}|jjDcic]\}}||j }}}nXt|t"rD|j$}|j&jDcic]\}}||j }}}nd}i} Dcgc]=}t)||t*x}t*ur"||j-|t*|||vr||f?c}St/d|t0j2} t5| cc}}wcc}}wcc}}wcc}}wcc}w)Nc3<K|]}t|tywrrrs rUrzGCompiledStateGraph.attach_node.._get_updates..r r c36K|]\}}|vs ||fywrrn)rkv output_keyss rUrzGCompiledStateGraph.attach_node.._get_updates..s%''+q![HXQF's  rnzExpected dict, got )message error_code)rPrkrrFr r r rrmrrrQrrmodel_fields_set model_fieldsdefaultr__fields_set__ __fields__r]r(rr0r-INVALID_GRAPH_NODE_RETURN_VALUEr.) rerrrrtkeepdefaultsvaluemsg _get_updatesrs rUr%z4CompiledStateGraph.attach_node.._get_updatessc}E4(+0;;=M41aA'>'@#q!ADTQF54-0>>>13>A!!W-77gnn4$'/0/B/B/D' |A'<"=>E{"!"q(9eY//4/E/ED9>9K9K9Q9Q9STA199 THT{3 //D9:9K9K9MNA199 NHND!H) !(7!;;GK)#<<73? ,d J  +1%9(HH)--oN. U O s) I5I5 I; I;J$JAJ r)mappertags)r(triggersrrwritersrF)guard)r)rrr&r*rdrfbound)!r3rrtrerr<rrrrsr=r rrrmrlrrkrBr?r,r@rqrMrCHANNEL_BRANCH_TOformatr" _pick_mapperrrdrfrcr) rrrXrrr write_entriesr input_valuesis_single_inputbranch_channelr%rs @@rUrzCompiledStateGraph.attach_nodesa %<!LL001C1CDJJLAq'*K t||445 LL006689Aq,Q/9K  -S -XhuS#X.G%H -,= .tS)= . huS#X/ 0= .B #$/J<$?y\ W  %<( \%m:,GH DJJsO  )-4::4<<3F3FL*.,,*>*>|*LMQAqDMLM!,/14S|9SO.55c:N,:3e,LDMM. )(()0?$|,\#& LL++L9 &m:,GH!..mmDJJsO" Q 9XNs J-+J3 J9rrc Jt|trZ|tk7rP|j|jj t ttj|dfyy|tk7rddj|d|}ttt||j|<|j|jj ||D]E}|j|jj t t||ftgGyy)Nzjoin:+:r')rPrlr2rqr*rr@rAr-r.rr$rrrr)r,)rrr channel_namers rUrzCompiledStateGraph.attach_edgeTs fc "cz 6"**11 *+<+C+CC+H$OQ CZ"388F#3"4AcU;L*;CV*MDMM, ' JJsO $ $ + +L 9  5!))00 *<?A  rWTrrrrrc dttttfdtddffd }j xsQ|j jvr#|j jjn|j j}|jjjj||rt|j |ndjrjtk7rj rj j#n3|j jDcgc]}|jk7s|c}}ddd} t%t|j&| <|jjj(j| |D]O} | tk7s |j| jjt+t-| | gt.gQyyycc}w) NpacketsrrNc2|Dcgc]}|tk7s |c}x}r|Dcgc]3}t|tsttj |dn|5}}j rhj tk7rU|jtdddt|Dchc] }t|tr |jn|"c}tj|tttttf|yycc}wcc}wcc}w)Nbranch:r6::then)r2rPr6rAr-r.rrr!rXr@do_writerrr)r9rpfilteredwritesrrrs rU branch_writerz7CompiledStateGraph.attach_branch..branch_writerns (/;!!s(A;;x;&   *!T2**;*B*B1*EtL;;6;;##5MM)%eWAdV6:(OW X!:a+>A!E X%%D%6G0G*H!I6R%<;!YsD D 8D%Dr;r6r<r')rrrlr6rrrrqrerMr*rrun_get_state_readerrr2rgvaluesr rrr)r@rAr,) rrrrrrArMrXrgr7rs ``` rUrz CompiledStateGraph.attach_branchks eCI./ 9G   2$$  *** LL  u % + +$$  5!!(( JJ;F!$,,7D   ;;6;;#-;; ""$'+||'9'9QtTV[[=PdQ  %UG1TF&9L*=c*BDMM, ' JJv{{ # , , 3 3L A #:JJsO++22$.|SAB* .;Rs <HH checkpointct|d}|d}|d}|sy|ddk\ryt|D]}|jds|jdd }||jvr8d |}||vrt |||j |n|j |}|j |i|j tifD]4} || vs| j |} || vrt | | || |<0| | |<6||vr||vr|j |||<|||<t|D]}|jd s|jddk(s+|jdd }||jvrNd |}||vrt |||j |n|j |}|j |i|j tifD]4} || vs| j |} || vrt | | || |<0| | |<6||vr||vr|j |||<|||<t|jj|sgtt} |jjD]-\} } | tk7s| tk7s| | j!| /t|D]}|tk(r||jvs|j |}|j |t"}| |D]} d | }||vrt |||n|}|j | i|j tifD]4} || vs| j |} || vrt | | || |<0| | |<6||vr |t"ur|||<|||<t|vs|tj |t"yy) z+Migrate a checkpoint to new channel layout.channel_valueschannel_versions versions_seenNrzstart:r6rz branch:to:r;)r startswithsplitrqmaxpoprr'countr isdisjointrrrr3r2rr()rrErDversionsseenrrXnew_knew_vssssource_to_targetrrrcs rU_migrate_checkpointz&CompiledStateGraph._migrate_checkpoints,-01/*  c?a  h (A||H%wws|Atzz)$TF+(a9!a  88D"-txx 2/FG*BBwFF1I B;(+Ar%y(9BuI()BuI *&1;$*JJqMF5M"'3 (8h (A||I&1773<1+<wws|B'tzz)$TF+(a9!a  88D"-txx 2/FG*BBwFF1I B;(+Ar%y(9BuI()BuI *&1;$*JJqMF5M"'3 (64::))(3*40 "ll00 8 sE>cSj$U+2237 8(^ 8: ? QA 1g.A/20",SE 2;@H;LHUOQ 7RS#'88C#4dhhy"6M"N2B Bw$&FF1I#(B;03Ar%y0ABuI01BuI 2!.1G3C,-F5M*/!0$!D(Y++Aw73 8 4rWr)rZrhrirprjrrrQrrrrlrbrrrrr1rrr%rZrnrWrUrrs 26 ~. i 26 ~. i JsJ(=*AJdJX%Xc](:";#$0MQ:: #:-3:EI: :xf8jf8Tf8rWrrc t|j}t|j|}ttj |dgk(r|dn|dt |||j|S)NrrT)selectfreshr&)rrrrtrr>do_readr/r)rrM state_keysr\s rUrCrCsig&&'J '//&) *F "zl2vayJ0B0B60JK  rWr_rc|dgk(ryt|r3t|tryt|ttfr t ||St t|S)Nr)rrrkrrr7r _coerce_state)r_rMrs rUr/r/sNj\!v fd # fy+6 7' ; ; =& ))rWrec|di|S)Nrnrn)rMres rUrara+s ?E?rWr#cbt|tr|gSg}t|tr|j|n?t|tt fr)|D]$}t|ts|j|&g}|D]}|j tjk(r t|t|jtr|j|jat|jtr|j|j|j|j|Sr rPr6rFrrrmr r r/gotorlrr#commandscmdrcommands rU_control_branchrj/s%w H%! ED%= ) %C#w'$ %#%C% ==GNN *( ( gllD ) JJw|| $  c * JJw|| $ JJw|| $% JrWcjKt|tr|gSg}t|tr|j|n?t|tt fr)|D]$}t|ts|j|&g}|D]}|j tjk(r t|t|jtr|j|jat|jtr|j|j|j|j|Swrrdrfs rU_acontrol_branchrlFs%w H%! ED%= ) %C#w'$ %#%C% ==GNN *( ( gllD ) JJw|| $  c * JJw|| $ JJw|| $% Js A#D3&C D3F)r(rrecursefunc_accepts_configc t|dsdtd|diiifSt|d}|jDcic]\}}|dk7r |t||}}}|jDcic]\}}t |t s||c}}|jDcic]\}}t |s||c}}|fScc}}wcc}}wcc}}w)NrjrFr{T)include_extras __slots__)hasattr _get_channelrrrPrr<)rMrrrall_keysrrs rUrrhs 6, - j&N O     tq.AAB   JBsC2C  C &C:Cr annotationr|cyrrnrrur|s rUrsrssrWTr{cyrrnrws rUrsrss,/rWct||x}r|r|Std|dt|x}r ||_|St |x}r ||_|St |}||_|S)NzThis z not allowed in this position)_is_field_managed_valuer_is_field_channelr_is_field_binopr#)rrur|managerrfallbacks rUrsrss*$ ;;w; NuZL0MNO O%j1 1 1 #J/ / / #J/HHL OrWrc,t|dr|j}t|dk\rt|dtr|dSt|dk\rHt |dr:t |dtr'|dt|dr|jS|Sy)N __metadata__rrK __origin__)rrrrrPrrrr)rmetas rUr{r{ssN# t9>jb;?8O Y!^R 1jb;6W48gc<.HCNNR RcR R rWc2t|dr|j}t|dk\rqt|drct |d}t |j j}td|Ddk(rt||dStd|y)NrrrKc3dK|](}|j|j|jfv*ywr)kindPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORD)rr>s rUrz"_is_field_binop..s2FFq00!2I2IJJs.0ryz5Invalid reducer signature. Expected (a, b) -> c. Got ) rrrrr\rrrrDsumrr)rrsigparamss rUr|r|ssN# t9>htBx0DH%C#..//12F#  /sDH== KC5Q rWcjt|dr|j}t|dk\rt|dxs|d}t |rmt |t r[|jjD]>\}}|tur||j|<|tus&|j|j|<@|Sy)NrrrK) rrrrrr<rPr:kwargsrr8r9r)rrr decorationrrs rUrzrzssN# t9>#DH-9bJ +j*@A * 1 1 7 7 9B1 5537J--a0 6636>>J--a0 B "! rWrtrrc t|rt|ttfr|St ||j }t |dk(r'|ddk(rt|||djdfSt|||Dcic]C}||vr=t||tr*|||jt|||j|fEc}Scc}w)Nrrr)root)field_definitions) rrrrrrrrI UpdateTyperPrrH)rrtrrrrrs rUrrs s| 3K(@A GCL%%'( t9>d1g3tAw'22D9   %S\ #H}HQK)M  ..- ! ( 6 6 #   #  #sAC z branch:to:{})rloggingrRrS collectionsr functoolsrrrrrtypesr r r r r rrrrrrrrrrrlangchain_core.runnablesrrpydanticr pydantic.v1rtyping_extensionsrlanggraph._api.deprecationrlanggraph.channels.baserlanggraph.channels.binopr(langgraph.channels.dynamic_barrier_valuer r!"langgraph.channels.ephemeral_valuer"langgraph.channels.last_valuer#&langgraph.channels.named_barrier_valuer$langgraph.checkpoint.baser%langgraph.constantsr&r'r(r)r*r+r,langgraph.errorsr-r.r/r0langgraph.graph.branchr1langgraph.graph.graphr2r3r4r5r6langgraph.graph.schema_utilsr7langgraph.managed.baser8r9r:r;r<r=langgraph.pregel.readr>r?langgraph.pregel.writer@rArBlanggraph.store.baserClanggraph.typesrDrErFrGlanggraph.utils.fieldsrHlanggraph.utils.pydanticrIlanggraph.utils.runnablerJrKrL getLoggerrZrrVrlr`rbrprrCrkr/rarjrlCONTROL_BRANCH_PATHrrmrrsrr{r|rzrQrr-rnrWrUrs #<<$>0"B/<V=3D0 *>: +CC41WW   8 $ uT#Y^'<  @@#@GJGz#z#z\8\8~   !%c  ~#$  *  *'+Cy *>FtCQTH~>V * hucz"# *$s)DcNtCH~38E#t),<#=.#(5d3C*D.'    +T2 J 4[ !4-=(=#>S#X NO.  29%.   BF/ //29$-/ ;( ()/ / :> 26 ;( ()(49+)>cx0G'H*#DI(CS:T"          )_ F#rW