ޠjV6&SSKJr SSKrSSKrSSKJrJrJr SSKJ r SSK J r J r SSK Jr SSKJr SSKJr SS KJrJr SS KJr SS KJr \R4"\5rSS jr"S S5r"SS\\\ 45r "SS5r!"SS5r"g)) annotationsN) AsyncIteratorIteratorMapping) TracebackType)Anycast)RunnableConfig)AsyncThreadStream)SyncThreadStream)LangGraphClientSyncLangGraphClient) DataDecoder)Commandc[U[5(a9UR(dUR(a [ S5eUR $U$)acTranslate a local `Command` into the v3 wire `input`, else passthrough. The v3 server decides start-vs-resume from thread state (an interrupted run or pending interrupts) and, on resume, wraps the whole `input` as `{"resume": input}` itself. So a resume `Command` must surface its raw `resume` value as the wire `input` (not the serialized dataclass, which the server would double-wrap). The v3 `run.start` path has no `goto` / `update` channel, so those are rejected. `langgraph_sdk` is upstream of `langgraph`, so this `Command`-aware marshalling lives here on the adapter (langgraph) side of the boundary. z}RemoteGraph v3 streaming supports `Command(resume=...)` only; `goto` / `update` are not supported by the v3 `run.start` path.) isinstancergotoupdateNotImplementedErrorresume)inputs ]/var/www/html/gaurav/venv/lib/python3.13/site-packages/langgraph/pregel/_remote_run_stream.py_translate_command_inputrsB%!! ::%R || Lc@\rSrSrSrS SjrS SjrS SjrS SjrSr g) _ChannelProjection,uDecoded projection for a wire channel the SDK doesn't type natively. Subscribes to `channel` and decodes each event's `params["data"]` through the SDK's `DataDecoder` — the same decoder the SDK's own plain-payload projections (`values` / `updates` / `checkpoints` / `tasks`) use, which yields the item shape that local's `UpdatesTransformer` / `CheckpointsTransformer` / `TasksTransformer` / `CustomTransformer` push, so iterating this matches the corresponding local projection. Iterate with `for` against a sync stream and `async for` against an async stream (matching the underlying SDK). Opening the subscription requires the stream to be entered (`with` / `async with`). cXlX lgN)_sdk_channel)selfsdkchannels r__init___ChannelProjection.__init__9s   rc## [UR5n[[[UR R UR/55nUHnURU5ShvN M gN 7fr)rr!r rrr subscribefeed)r"decodereventsevents r__iter___ChannelProjection.__iter__=sWdmm,hsmTYY%8%8$--%IJE||E* * * *sA*A8,A6- A8c"UR5$r)_aiterr"s r __aiter___ChannelProjection.__aiter__Ds{{}rc# [UR5n[[[UR R UR/55nUShvN nURU5HnU7v M M(N# g7fr)rr!r rrr r(r))r"r*r+r,items rr0_ChannelProjection._aiterGsbdmm,mC($))*=*=t}}o*NO! % U+ , 6s*ABA?A=A? B=A??B)r!r N)r#$AsyncThreadStream | SyncThreadStreamr$strreturnNoner9z Iterator[Any]r9zAsyncIterator[Any]) __name__ __module__ __qualname____firstlineno____doc__r%r-r2r0__static_attributes__rrrr,s  +rrcR\rSrSrSrSrSr\\-rS SjrS Sjr S Sjr SSjr S r g )_ProjectionRegistryPuiRead-only name -> projection registry mirroring local `GraphRunStream.extensions`. Resolution follows the langchain-protocol wire channels, and every entry yields the same decoded item shape local does (`params.data`): - `values` / `messages` / `tool_calls` / `subgraphs` resolve to the SDK's decoded typed projections. `tool_calls` is the `tools` channel — tool *execution* events, distinct from the tool-call *inputs* inside `messages`. - `updates` / `checkpoints` / `tasks` / `custom` have no typed SDK projection, so they resolve to a `_ChannelProjection` that subscribes to the channel and yields `params.data` — matching the local transformer output for those channels. - any other name is a specific custom-extension channel (`thread.extensions[name]`, i.e. `custom:`). `lifecycle` is intentionally absent: local derives a status payload from it rather than yielding `params.data`, and the SDK consumes it as control-plane (driving `output` / `interrupted`), so its shape can't be matched — it remains reachable via the raw `events` iterator. `debug` is absent too: it is not a v3 wire channel. )valuesmessages tool_calls subgraphs)updates checkpointstaskscustomcXlgrr )r"r#s rr%_ProjectionRegistry.__init__ms rcXR;a[URU5$XR;a[ URU5$URR U$r)_TYPEDgetattrr _DECODEDr extensions)r"names r __getitem___ProjectionRegistry.__getitem__psM ;; 499d+ + == %dii6 6yy##D))rc,[UR5$r)iter_NATIVEr1s rr-_ProjectionRegistry.__iter__wsDLL!!rc,[UR5$r)lenr\r1s r__len___ProjectionRegistry.__len__zs4<<  rrPN)r#r7r9r:)rWr8r9r)r9z Iterator[str])r9int) r=r>r?r@rArSrUr\r%rXr-r`rBrCrrrErEPs1.?F GraphRunStream surface.cnXlX l[U5UUS.UlSUlSUlSUlgN)rconfigmetadataF)_clientr r _start_kwargs_run_id_closed _events_iter)r" sync_client sdk_threadrrhris rr%_RemoteGraphRunStream.__init__s>#  -e4 .  $(  26rc^UR(a [S5eURR5 URRR "S0UR D6nUSUl U$![a. URR"[R"56 ef=f)Nz$_RemoteGraphRunStream already closedrun_idrC) rm RuntimeErrorr __enter__runstartrk BaseException__exit__sysexc_inforlr"results rru_RemoteGraphRunStream.__enter__s <<EF F  YY]]((>4+=+=>Fh'    II    /  s 0A448B,cnUR(agSUlURRXU5 gNT)rmr ryr"exc_typeexctbs rry_RemoteGraphRunStream.__exit__s) <<   8"-rc.URR$rr outputr1s rr_RemoteGraphRunStream.outputsyyrc.URR$)aHWhether the remote run is currently paused at an interrupt. Reads the SDK's current value without blocking. This differs from local `GraphRunStream.interrupted`, which drives the run to terminal before returning the flag. Sync callers needing a wait-for-interrupt pattern should switch to the async API and drain a projection. r interruptedr1s rr!_RemoteGraphRunStream.interruptedsyy$$$rc@[URR5$)z?Current outstanding interrupt payloads (non-blocking snapshot).listr interruptsr1s rr _RemoteGraphRunStream.interruptssDII(())rc.URR$zLive message-stream projection (mirrors local `run.messages`).r rHr1s rrH_RemoteGraphRunStream.messagesyy!!!rc.URR$z;Subgraph-handle projection (mirrors local `run.subgraphs`).r rJr1s rrJ_RemoteGraphRunStream.subgraphsyy"""rc.URR$zTool-execution projection (the `tools` channel). These are tool *execution* events (started / output / finished), distinct from the tool-call *inputs* carried inside `messages`. r rIr1s rrI _RemoteGraphRunStream.tool_callsyy###rc,[UR5$z=Name -> projection registry (mirrors local `run.extensions`).rEr r1s rrV _RemoteGraphRunStream.extensions#499--rcUR(agSUlURbDURRR UR R URSS9 UR R5 g![a [RSSS9 Nr?r@rAr%rurypropertyrrrrGrHrJrIrVrr-rrBrCrrrdrd~s'C7)7% 7  7 & 7(7 7(  ., ." . ! .  .  %%**  ""##$$.. C! Arrdc\rSrSrSrSSjrSSjrSSjrSSjrSSjr SSjr \ SS j5r \ SS j5r \ SS j5r\ SS j5r\ SS j5rSSjrSSjrSrg)_AsyncRemoteGraphRunStreamz@Async adapter: AsyncThreadStream -> AsyncGraphRunStream surface.cnXlX l[U5UUS.UlSUlSUlSUlgrg)rjr rrkrlrm _events_aiter)r"clientrprrhris rr%#_AsyncRemoteGraphRunStream.__init__s>  -e4 .  $(  8<rc# UR(a [S5eURR5IShvN URRR "S0UR D6IShvN nUSUl U$NIN![a7 URR"[R"56IShvN ef=f7f)Nz)_AsyncRemoteGraphRunStream already closedrsrC) rmrtr __aenter__rvrwrkrx __aexit__rzr{rlr|s rr%_AsyncRemoteGraphRunStream.__aenter__ s <<JK Kii""$$$ 99==..D1C1CDDFh'   %D ))%%s||~6 6 6  sE:CBC3B 5B6B : CB 9C CC  Cc# UR(agSUlURRXU5IShvN gN7fr)rmr rrs rr$_AsyncRemoteGraphRunStream.__aexit__s2 <<  ii!!(444s9AAAcJ# URRIShvN $N7f)aDrive the remote run to completion and return the final state. Awaits the SDK's terminal-state awaitable, matching local `AsyncGraphRunStream.output()` (a method, not a property, so `run.output` without `await` fails at type-check time rather than silently yielding a coroutine). Nrr1s rr!_AsyncRemoteGraphRunStream.output"sYY%%%%%s #!#c6# URR$7f)aWhether the remote run is currently paused at an interrupt. Reads the SDK's current value without blocking. This differs from local `AsyncGraphRunStream.interrupted()`, which drives the run to terminal before returning the flag. Callers that need a wait-for-interrupt pattern should drain a projection (e.g., `async for snap in stream._sdk.values`) until the SDK's paused sentinel fires, then call this method. rr1s rr&_AsyncRemoteGraphRunStream.interrupted,syy$$$scH# [URR5$7f)zCurrent outstanding interrupt payloads. Non-blocking; reads the SDK's current snapshot. See `interrupted` for the divergence from local v3 semantics. rr1s rr%_AsyncRemoteGraphRunStream.interrupts8s DII(())s "c.URR$rrr1s rrG!_AsyncRemoteGraphRunStream.values@rrc.URR$rrr1s rrH#_AsyncRemoteGraphRunStream.messagesErrc.URR$rrr1s rrJ$_AsyncRemoteGraphRunStream.subgraphsJrrc.URR$rrr1s rrI%_AsyncRemoteGraphRunStream.tool_callsOrrc,[UR5$rrr1s rrV%_AsyncRemoteGraphRunStream.extensionsXrrc# UR(agSUlURbLURRR UR R URSS9IShvN UR R5IShvN gN(![a [RSSS9 NFf=fN+![a [RSSS9 gf=f7frrr1s rr _AsyncRemoteGraphRunStream.abort]s <<  << # Ill''..II''E/  C))//# # #  I 84 H I $ C LL2TL B Csk'C%AB0B1B6CB?CC%BB<9C%;B<<C%?CC"C%!C""C%cURc)URRR5UlUR$r)rr r+r2r1s rr2$_AsyncRemoteGraphRunStream.__aiter__ms5    %!%!1!1!;!;!=D !!!r)rjrmrrlr rkN) rr rpr rrrhrrirr9r:)r9rrrrrrrr<)r=r>r?r@rAr%rrrrrrrGrHrJrIrVrr2rBrCrrrrsJ= =& =  = & =(= =(  5, 5" 5 ! 5  5& %*  ""##$$..C "rr)rrr9r)# __future__rloggingrzcollections.abcrrrtypesrtypingrr langchain_core.runnablesr langgraph_sdk._async.streamr langgraph_sdk._sync.streamr langgraph_sdk.clientr rlanggraph_sdk.stream.decodersrlanggraph.typesr getLoggerr=rrrr8rErdrrCrrrs}" <<397E5#   8 $.!!H+!'#s(++!\sAsAl|"|"r