tjV6@ddlmZddlZddlZddlmZmZmZddlm Z ddl m Z m Z ddl mZddlmZddlmZdd lmZmZdd lmZdd lmZejeZddZGddZGddeee fZ GddZ!GddZ"dS)) annotationsN) AsyncIteratorIteratorMapping) TracebackType)Anycast)RunnableConfig)AsyncThreadStream)SyncThreadStream)LangGraphClientSyncLangGraphClient) DataDecoder)Commandinputrreturncxt|tr$|js|jrt d|jS|S)aTranslate 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)rs a/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/langgraph/pregel/_remote_run_stream.py_translate_command_inputrsP%!! :  %R | Lc2eZdZdZddZdd Zdd Zdd ZdS)_ChannelProjectionuDecoded 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`). sdk$AsyncThreadStream | SyncThreadStreamchannelstrrNonec"||_||_dSN)_sdk_channel)selfrr s r__init__z_ChannelProjection.__init__9s  r Iterator[Any]c#Kt|j}ttt|j|jg}|D]}||Ed{VdSr$)rr&r rrr% subscribefeed)r'decodereventsevents r__iter__z_ChannelProjection.__iter__=s|dm,,hsmTY%8%8$-%I%IJJ + +E||E** * * * * * * * * + +rAsyncIterator[Any]c*|Sr$)_aiterr's r __aiter__z_ChannelProjection.__aiter__Ds{{}}rcKt|j}ttt|j|jg}|23d{V}||D]}|WV%6dSr$)rr&r rrr%r+r,)r'r-r.r/items rr3z_ChannelProjection._aiterGsdm,,mC($)*=*=t}o*N*NOO!       % U++    "66sA<N)rrr r!rr"rr)rr1)__name__ __module__ __qualname____doc__r(r0r5r3rrrr,sn      ++++rrcDeZdZdZdZdZeezZddZdd ZddZ ddZ dS)_ProjectionRegistryuRead-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 checkpointstaskscustomrrrr"c||_dSr$)r%)r'rs rr(z_ProjectionRegistry.__init__ms  rnamer!rc||jvrt|j|S||jvrt |j|S|jj|Sr$)_TYPEDgetattrr%_DECODEDr extensions)r'rJs r __getitem__z_ProjectionRegistry.__getitem__psP 4;  49d++ + 4= %di66 6y#D))r Iterator[str]c*t|jSr$)iter_NATIVEr4s rr0z_ProjectionRegistry.__iter__wsDL!!!rintc*t|jSr$)lenrTr4s r__len__z_ProjectionRegistry.__len__zs4<   rN)rrrr")rJr!rr)rrQ)rrU) r:r;r<r=rLrNrTr(rPr0rXr>rrr@r@Ps.?F GraphRunStream surface. sync_clientr sdk_threadr rrconfigRunnableConfig | Nonemetadatadict[str, Any] | Nonerr"c|||_||_t|||d|_d|_d|_d|_dSN)rr]r_F)_clientr%r _start_kwargs_run_id_closed _events_iter)r'r[r\rr]r_s rr(z_RemoteGraphRunStream.__init__sP#  -e44 . .  $(  26rc|jrtd|j |jjjdi|j}n/#t$r"|jjtj wxYw|d|_ |S)Nz$_RemoteGraphRunStream already closedrun_idr>) rf RuntimeErrorr% __enter__runstartrd BaseException__exit__sysexc_inforer'results rrkz_RemoteGraphRunStream.__enter__s < GEFF F  (TY](>>4+=>>FF    DI   / /  h'  s A,A:exc_typetype[BaseException] | NoneexcBaseException | NonetbTracebackType | Nonec^|jrdSd|_|j|||dSNT)rfr%ror'rtrvrxs rroz_RemoteGraphRunStream.__exit__s: <  F  8S"-----rc|jjSr$r%outputr4s rrz_RemoteGraphRunStream.outputs yrboolc|jjS)apWhether 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% interruptedr4s rrz!_RemoteGraphRunStream.interruptedsy$$r list[Any]c4t|jjS)z?Current outstanding interrupt payloads (non-blocking snapshot).listr% interruptsr4s rrz _RemoteGraphRunStream.interruptssDI()))rc|jjSzLive message-stream projection (mirrors local `run.messages`).r%rBr4s rrBz_RemoteGraphRunStream.messagesy!!rc|jjSz;Subgraph-handle projection (mirrors local `run.subgraphs`).r%rDr4s rrDz_RemoteGraphRunStream.subgraphsy""rc|jjSzTool-execution projection (the `tools` channel). These are tool *execution* events (started / output / finished), distinct from the tool-call *inputs* carried inside `messages`. r%rCr4s rrCz _RemoteGraphRunStream.tool_callsy##rMapping[str, Any]c*t|jSz=Name -> projection registry (mirrors local `run.extensions`).r@r%r4s rrOz _RemoteGraphRunStream.extensions#49---rc|jrdSd|_|j_ |jj|jj|jdn,#t$rt ddYnwxYw |j dS#t$r t ddYdSwxYwNTF)waitzabort: runs.cancel failed)rqzabort: sdk.close failed rfrercrunscancelr% thread_id Exceptionloggerdebugcloser4s rabortz_RemoteGraphRunStream.aborts <  F < # I !(()rrrZrZ~sCC7777(     . . . .   X %%%X%***X*   X """X"###X#$$$X$...X. C C C C!!!! AAAAAArrZceZdZdZd&dZd'dZd(dZd)dZd*dZd+dZ e d)dZ e d)dZ e d)dZ e d)dZe d,d!Zd-d"Zd.d$Zd%S)/_AsyncRemoteGraphRunStreamz@Async adapter: AsyncThreadStream -> AsyncGraphRunStream surface.clientr r\r rrr]r^r_r`rr"c|||_||_t|||d|_d|_d|_d|_dSrb)rcr%rrdrerf _events_aiter)r'rr\rr]r_s rr(z#_AsyncRemoteGraphRunStream.__init__sP  -e44 . .  $(  8<rc@K|jrtd|jd{V |jjjdi|jd{V}n5#t$r(|jjtj d{VwxYw|d|_ |S)Nz)_AsyncRemoteGraphRunStream already closedrir>) rfrjr% __aenter__rlrmrdrn __aexit__rprqrerrs rrz%_AsyncRemoteGraphRunStream.__aenter__ s < LJKK Ki""$$$$$$$$$ .49=.DD1CDDDDDDDDFF   %$)%s|~~6 6 6 6 6 6 6 6  h'  s "A2BrtrurvrwrxrycnK|jrdSd|_|j|||d{VdSr{)rfr%rr|s rrz$_AsyncRemoteGraphRunStream.__aexit__sP <  F i!!(C44444444444rc*K|jjd{VS)aADrive 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). Nr~r4s rrz!_AsyncRemoteGraphRunStream.output"s%Y%%%%%%%%rrcK|jjS)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. rr4s rrz&_AsyncRemoteGraphRunStream.interrupted,sy$$rrc8Kt|jjS)zCurrent outstanding interrupt payloads. Non-blocking; reads the SDK's current snapshot. See `interrupted` for the divergence from local v3 semantics. rr4s rrz%_AsyncRemoteGraphRunStream.interrupts8s DI()))rc|jjSrrr4s rrAz!_AsyncRemoteGraphRunStream.values@rrc|jjSrrr4s rrBz#_AsyncRemoteGraphRunStream.messagesErrc|jjSrrr4s rrDz$_AsyncRemoteGraphRunStream.subgraphsJrrc|jjSrrr4s rrCz%_AsyncRemoteGraphRunStream.tool_callsOrrrc*t|jSrrr4s rrOz%_AsyncRemoteGraphRunStream.extensionsXrrcK|jrdSd|_|je |jj|jj|jdd{Vn,#t$rt ddYnwxYw |j d{VdS#t$r t ddYdSwxYwrrr4s rrz _AsyncRemoteGraphRunStream.abort]s* <  F < # Il'..I'E/ I I I 84 HHHHH I C)//## # # # # # # # # # C C C LL2TL B B B B B B Cs#7A&A<;A<B!!&C  C r1cd|j#|jj|_|jSr$)rr%r.r5r4s rr5z$_AsyncRemoteGraphRunStream.__aiter__ms-   %!%!1!;!;!=!=D !!rN) rr r\r rrr]r^r_r`rr")rrrrrrrrr9)r:r;r<r=r(rrrrrrrArBrDrCrOrr5r>rrrrs^JJ====(     5 5 5 5&&&& % % % %****   X """X"###X#$$$X$...X.CCCC """"""rr)rrrr)# __future__rloggingrpcollections.abcrrrtypesrtypingrr langchain_core.runnablesr langgraph_sdk._async.streamr langgraph_sdk._sync.streamr langgraph_sdk.clientr rlanggraph_sdk.stream.decodersrlanggraph.typesr getLoggerr:rrrr!r@rZrr>rrrs"""""" <<<<<<<<<<333333999999777777EEEEEEEE555555######  8 $ $.!!!!!!!!H+!+!+!+!+!'#s(++!+!+!\sAsAsAsAsAsAsAsAl|"|"|"|"|"|"|"|"|"|"r