ޠj/*SSKJr SSKrSSKJrJrJrJr SSKJ r SSK J r J r SSK JrJrJr SSKJrJr SSKJrJr SS KJrJr SS KJrJr SS KJrJr SS K J!r! \(aSS K"J#r#J$r$ SSK%J&r& \RN"\(5r)"SS\5r*"SS\5r+"SS\5r,"SS\5r-\Sr.S+Sjr/"SS\SS9r0"SS\5r1S,Sjr2S-S jr3"S!S"\15r4"S#S$\15r5"S%S&\5r6"S'S(\5r7"S)S*\5r8g).) annotationsN) TYPE_CHECKINGAnyLiteralcast)message_to_events)AsyncChatModelStreamChatModelStream)AIMessageChunk BaseMessage ToolMessage)LifecycleCause MessagesData) NotRequired TypedDict) GraphDrainedGraphInterrupt) ProtocolEventStreamTransformer)AsyncSubgraphRunStreamSubgraphRunStream) StreamChannel) AwaitableCallable) StreamMuxcd^\rSrSrSrSrSrS S U4SjjjrS Sjr\ S Sj5r SSjr S r U=r $)ValuesTransformeruCapture values events as a drainable stream of state snapshots. Provides the `run.values` projection. `run.output`, `run.interrupted` and `run.interrupts` are tracked directly by the run stream and do not depend on this transformer. Native transformer — projection keys are exposed as direct attributes on the run stream (e.g. `run.values`). Only values events at the run's own level are captured; snapshots from deeper subgraphs are left in the main event log but excluded from the projection. "Own level" is defined by `scope`, which `stream_events(version="v3")` / `astream_events(version="v3")` populate from the caller's checkpoint namespace so that a nested `stream_events(version="v3")` call still sees its own root snapshots. T)valuesc>[TU]U5 [5UlSUlSUl/Ul[U5Ulg)NF) super__init__r_log_latest _interrupted _interruptslist _scope_listselfscope __class__s W/var/www/html/gaurav/venv/lib/python3.13/site-packages/langgraph/stream/transformers.pyr"ValuesTransformer.__init__1s> 3@? .2 !&('+5kcSUR0$)Nrr#r*s r-initValuesTransformer.init;$))$$r/c.URR$)zpThe error that ended the run, or `None` if it succeeded. Set by the mux when it auto-fails the projection log. )r#_errorr2s r-errorValuesTransformer.error>s yyr/cUSS:wagUSnUSUR:wagUSUlURSS5nU(a"SUlURR U5 UR RUS5 g) NmethodrTparams namespacedata interrupts)r(r$getr%r&extendr#push)r*eventr<r?s r-processValuesTransformer.processFs ?h &x + $"2"2 2f~ ZZ b1  $D     # #J / vf~&r/)r%r&r$r#r(r@r+tuple[str, ...]returnNonerJdict[str, Any]rJzBaseException | NonerDrrJbool)__name__ __module__ __qualname____firstlineno____doc___nativerequired_stream_modesr"r3propertyr8rE__static_attributes__ __classcell__r,s@r-rrsB"G'22%    r/rcP^\rSrSrSrSrSrS S U4SjjjrS SjrS Sjr Sr U=r $) CustomTransformerUuCapture custom events as a drainable stream of arbitrary payloads. Nodes emit custom data via `get_stream_writer()`. This transformer surfaces those events on `run.custom` as a `StreamChannel[Any]`, preserving payloads in arrival order. Only events at the run's own scope are captured; custom data from deeper subgraphs is available on the respective subgraph handle's `.custom` projection. Native transformer — `run.custom` is a direct attribute. T)customcb>[TU]U5 [5Ul[ U5UlgNr!r"rr#r'r(r)s r-r"CustomTransformer.__init__fs% (5 &*5kr/cSUR0$)Nr_r1r2s r-r3CustomTransformer.initkr5r/cUSS:wagUSnUSUR:wagURRUS5 g)Nr;r_Tr<r=r>r(r#rCr*rDr<s r-rECustomTransformer.processnsG ?h &x + $"2"2 2 vf~&r/r#r(rGrHrLrO rQrRrSrTrUrVrWr"r3rErYrZr[s@r-r]r]Us. G'22 %r/r]cP^\rSrSrSrSrSrS S U4SjjjrS SjrS Sjr Sr U=r $) UpdatesTransformerxuCapture updates events as a drainable stream of node outputs. Surfaces `stream_mode="updates"` data on `run.updates` as a `StreamChannel[dict[str, Any]]`. Each item is a dict mapping a node (or task) name to the update it returned after a step. Only events at the run's own scope are captured; updates from deeper subgraphs are available on the respective subgraph handle's `.updates` projection. Native transformer — `run.updates` is a direct attribute. T)updatescb>[TU]U5 [5Ul[ U5Ulgrarbr)s r-r"UpdatesTransformer.__init__% 3@? &*5kr/cSUR0$)Nror1r2s r-r3UpdatesTransformer.inits499%%r/cUSS:wagUSnUSUR:wagURRUS5 g)Nr;roTr<r=r>rgrhs r-rEUpdatesTransformer.processsG ?i 'x + $"2"2 2 vf~&r/rjrGrHrLrOrkr[s@r-rmrmxs. G(22 &r/rmc^\rSrSrSrSrSrSSU4SjjjrSSjrSSjr SSjr SS jr SS jr SS jr SS jrSS jrSSjrSrU=r$)MessagesTransformeruCapture messages events as ChatModelStream objects. The messages projection yields one `ChatModelStream` (or `AsyncChatModelStream`) per LLM call. Consumers iterate `run.messages` to get stream handles, then use each handle's typed projections (`.text`, `.reasoning`, `.tool_calls`, `.usage`, `.output`) for per-message content. Two input shapes are handled (via `params["data"] = (payload, metadata)` from `StreamMessagesHandler`): 1. Protocol event (dict with `"event"` key) — emitted by `stream_events(version="v3")` / `astream_events(version="v3")` via the `on_stream_event` callback. Routed to an existing `ChatModelStream` by `metadata["run_id"]`. A `message-start` event creates a new stream; `message-finish` closes it. 2. Whole `AIMessage` — emitted from `on_chain_end` when a node returns a finalized message. Replayed as a synthetic protocol event lifecycle via `message_to_events`, then the already-complete stream is pushed to the log. V1 `AIMessageChunk` tuples (from `on_llm_new_token`) are not streamed into this projection: chat models that want to populate `run.messages` with content-block streaming must use `stream_events(version="v3")` / `astream_events(version="v3")`. Models called via the legacy `stream()` method still surface their final `AIMessage` via `on_chain_end` when a node returns it as state. Only events at the run's own level are projected; tokens from deeper subgraphs are left in the main event log but excluded from `.messages`. "Own level" is defined by `scope`, which `stream_events(version="v3")` / `astream_events(version="v3")` populate from the caller's checkpoint namespace so that a `stream_events(version="v3")` call inside a node still sees its own root chat model streams on `.messages`. Consumers that need subgraph tokens should iterate the raw event stream or register a custom transformer. Native transformer — the `messages` projection is exposed as a direct attribute on the run stream. T)messagesc>[TU]U5 [5Ul0Ul[ 5UlSUlSUl[U5Ul gra) r!r"rr#_by_runset _ignored_runs_pump_fn _apump_fnr'r(r)s r-r"MessagesTransformer.__init__sH 4AO 46 '*u37 ?C'+5kr/cSUR0$)Nrzr1r2s r-r3MessagesTransformer.initsDII&&r/cXlg)zIWire the sync pull callback. Called by GraphRunStream._wire_request_more.N)rr*fns r- _bind_pumpMessagesTransformer._bind_pumps r/cXlg)zWire the async pull callback. Called by `AsyncGraphRunStream._wire_arequest_more` so each `AsyncChatModelStream` this transformer creates can drive the shared graph pump from its projection cursors. N)rrs r- _bind_apumpMessagesTransformer._bind_apumps r/cURb([UUUS9nURUR5 U$URb([ UUUS9nUR UR5 U$[UUUS9$)a6Create a ChatModelStream (sync) or AsyncChatModelStream (async). Wires whichever pump is bound. Prefers the async pump so nested iteration under `AsyncGraphRunStream` drives the graph forward without a background task. The unwired fallback (no pump bound) is used by unit tests that dispatch events manually. r=node message_id)rr set_arequest_morerr set_request_more)r*r=rrastreamstreams r- _make_stream MessagesTransformer._make_streams >> %*#%G  % %dnn 5N == $&5#%'F  # #DMM 2M#!  r/cUSS:wagUSnUSUR:wagUSup4URS5nU(a[URSS 55OS n[U[5(a!S U;aUR [ S U5XeS 9 g[U[5(a9[U[5(d$[U[5(dURX5S 9 g)Nr;rzTr<r=r>langgraph_noderun_idrDr)rr)r) r(rAstr isinstancedict_route_protocol_eventrr r r _route_whole_message)r*rDr<payloadmetadatarrs r-rEMessagesTransformer.process s ?j (x + $"2"2 2"6N#<<(894<X\\(B/0" gt $ $G);  & &^W-f '  w , ,w77w 44  % %g % 9 r/cVURS5nUS:XaURS5S:XaURRU5 gURS5nUR/UUb [ U5OSS9nX`R U'UR RU5 URU5 gX R;a#US:XaURRU5 ggX R ;a5UR UnURU5 US:XaUR U ggg)NrDz message-startroletoolrrzmessage-finish) rAr~addrrr|r#rCdispatchdiscard)r*rDrr event_typerrs r-r)MessagesTransformer._route_protocol_event$sYYw'  (yy F*""&&v.<0J&&.8.D3z?$'F $*LL IINN6 " OOE " )) )--""**62. || #\\&)F OOE "--LL(.$r/cUR/X!RS9n[XRS9HnURU5 M URR U5 g)Nr)r)ridrrr#rC)r*messagerrevts r-r(MessagesTransformer._route_whole_messageDsK""Rdzz"R$WDC OOC E vr/clURR5 URR5 g)uJClear any routing state — streams close themselves via `message-finish`.N)r|clearr~r2s r-finalizeMessagesTransformer.finalizeJs$    "r/c[URR55HnURU5 M URR 5 UR R 5 g)zCPropagate run error to any streams still open when the graph fails.N)r'r|rfailrr~)r*errrs r-rMessagesTransformer.failOsL4<<..01F KK 2    "r/)rr|r~r#rr(rGrHrL)rzCallable[[], bool]rJrK)rzCallable[[], Awaitable[bool]]rJrK)r= list[str]r str | NonerrrJr rO)rDrrrrrrJrK)rr rrrJrKrJrKr BaseExceptionrJrK)rQrRrSrTrUrVrWr"r3rrrrErrrrrYrZr[s@r-rxrxs'RG) 2 2'" "  "  "  " H6)) )  )  )@ # ##r/rx)started completedfailed interrupteddrainedcDURS5upnX(aU4$S4$)zSplit a namespace segment into `(graph_name, trigger_call_id)`. Segments are formatted `node_name:task_id` by `prepare_next_tasks`. Returns `(segment, None)` if no `:` is present. :N) partition)segmentnameseptask_ids r-_parse_ns_segmentrZs. !**3/Dw C ))T ))r/cV\rSrSr%SrS\S'S\S'S\S'S\S 'S \S 'S\S 'S rg)LifecyclePayloadidaPayload of a lifecycle event surfaced on the `lifecycle` channel. Auto-forwarded as `lifecycle` protocol events (no `custom:` prefix because `LifecycleTransformer` is a native transformer) so remote SDK clients receive the same data in-process consumers see via `run.lifecycle`. SubgraphStatusrDrr=zNotRequired[str] graph_nametrigger_call_idzNotRequired[LifecycleCause]causer8r@N)rQrRrSrTrU__annotations__rYr@r/r-rrds-   %% && r/rF)totalc^\rSrSrSrSrSSU4SjjjrSSjrSSjrSSjr SSjr SS jr SS jr SS jr SS jrSS jrSSjrSSjrSrU=r$)_TasksLifecycleBaseiuuShared bookkeeping for `tasks`-event-driven lifecycle inference. Both `LifecycleTransformer` (wire-serializable channel) and `SubgraphTransformer` (in-process navigation handles) discover subgraphs by watching the same `tasks` stream — `started` on the first event at a tracked namespace, terminal status when the parent's `TaskResultPayload` arrives. Centralizing the dispatch + open-set bookkeeping here keeps the inference rules from drifting between the two surfaces. Subclasses provide three template-method hooks: - `_should_track(ns)` — scope filter (e.g. multi-depth vs direct-children-only). - `_on_started(ns, graph_name, trigger_call_id)` — first sighting action (push payload / build handle / etc.). Called once per discovered namespace. - `_on_terminal(ns, status, error)` — terminal action (push terminal payload / mark handle status). Called once per tracked namespace at result time, or via `finalize` / `fail` sweeps if no parent result arrived. Tasks events are suppressed from the main event log (`process` returns False) — they're folded into whichever projection the subclass populates; consumers iterating the raw protocol stream see the higher-level view. taskscz>[TU]U5 [5Ul0Ul0Ul0UlSUlgra)r!r"r}_seen_open _lc_by_ns_pending_tool_calls_pending_causer)s r-r"_TasksLifecycleBase.__init__s? +.5 24 =? 46 6:r/c[e)uFScope filter — return True iff `ns` is in this transformer's region.NotImplementedErrorr*nss r- _should_track!_TasksLifecycleBase._should_tracks!!r/c[e)zFired once per discovered namespace (first observed task event). The triggering `cause` (if any) is available as `self._pending_cause`. r)r*rrrs r- _on_started_TasksLifecycleBase._on_starteds "!r/c[e)zkFired once per tracked namespace when its parent's result arrives, or via finalize/fail safety-net sweeps. r)r*rstatusr8s r- _on_terminal _TasksLifecycleBase._on_terminals "!r/cUSS:wag[USS5nUSSnSU;aURX#5 gURX#5 URU5 UR X#5 g) Nr;rTr<r=r>resultF)tuple_handle_task_result_record_identity_record_pending_tool_calls_handle_task_start)r*rDrr>s r-rE_TasksLifecycleBase.processs~ ?g % 5?;/ 0Xv& t   $ $R .  ! !" +  + +D 1  # #B -r/cXR;agURS5=(d 0nURS5URU'g)aQRecord this namespace's `lc_agent_name` (first task event wins). Runs for every task-start event, including `ns == self.scope` and tracked children. Pregel emits parent-namespace tasks before child-namespace tasks, so under that ordering the parent's identity is recorded by the time a child event is evaluated in `_handle_task_start`. Nr lc_agent_name)rrA)r*rr>rs r-r$_TasksLifecycleBase._record_identitys;   88J'-2%\\/:rr/c&URS5n[U[5(dgURS5nSn[U[5(aP[URS5[5(a,USRS5n[U[5(aUnO`[U[5(aKUHEn[U[5(dM[URS5[5(dM@USn O UbX@R U'gg)aHarvest a task's triggering tool_call_id keyed by its task id. A tool-dispatch task seeds `task_id -> tool_call_id`; the spawned subgraph's namespace segment `node:` shares that id, letting a subagent recover the tool call that caused it across payloads. Two input shapes are handled: the current Pregel push model schedules each tool call as its own task whose `input` is a `tool_call_with_context` dict, while a legacy / batched model passes a list of tool-call dicts. rNinput tool_call)rArrrr'r)r*r>rr tool_call_id candidatetcs r-r._TasksLifecycleBase._record_pending_tool_callss((4.'3'' ((7##'  gt $ $GKK 4Ld)S)S ,006I)S))(  & &b$''Jrvvd|S,I,I#%d8L  #0< $ $W - $r/cURU5(aXR;agURRU5 [US5up4UR S5=(d 0nUR S5nUSLnU(aUO U=(d SnSn U(a3Ub0UR R U5n U (aS[ U 5S.n XlURXU5 UbX@RU'gg)NrrtoolCall)typer) rrrrrArrrrr) r*rr> parsed_namerrchild_lc is_subagentrrrs r-r&_TasksLifecycleBase._handle_task_starts!!"%%zz)9  r'8B'@$ 88J'-2<<0d* !,X;3F$ '+ ?63377HL!+S=NO$ 9  &,JJrN 'r/cURS5nU(d/$/n[URR55HBupVUSSU:wdXc:waM[ U5upxUR XWU45 URU MD U$)z>Return and remove tracked children closed by this task result.rNr)rAr'ritems_terminal_from_resultappend) r*rr> result_id transitionschild_nsparent_task_idrr8s r-_pop_terminal_transitions-_TasksLifecycleBase._pop_terminal_transitions$sHHTN IPR (,TZZ-=-=-?(@ $H}"n&A1$7MF   %8 9 8$ )A r/c^URX5Hup4nURX4U5 M gra)r r)r*rr>r rr8s r-r'_TasksLifecycleBase._handle_task_result4s-'+'E'Eb'O #He   h 6(Pr/c[UR5HnURUSS5 M URR5 g)zAEmit `completed` for any tracked namespace still open at run end.rN)r'rrrrs r-r_TasksLifecycleBase.finalize8s7tzz"B   b+t 4# r/c[U5up#[UR5HnURXBU5 M URR 5 g)z:Emit terminal status for any tracked namespace still open.N)_status_from_exceptionr'rrr)r*rr error_strrs r-r_TasksLifecycleBase.fail>sB237tzz"B   b) 4# r/)rrrrrrGrHrrIrJrPrrIrrrrrJrKrrIrrr8rrJrKrO)rrIr>rMrJrK)r>rMrJrK)rrIr>rMrJz8list[tuple[tuple[str, ...], SubgraphStatus, str | None]]rr)rQrRrSrTrUrWr"rrrrErrrr rrrrYrZr[s@r-rrus8'::4" "  " "$ "  " "  " " "  " ;=<-<!)7 A 7 r/rct[U[5(ag[U[5(agS[U54$)zCMap a run exception to a subgraph terminal status and error string.)rNrNr)rrrr)rs r-rrFs1#|$$#~&&" SX r/c|URS5(agURS5nU(a S[U54$g)zMap a `TaskResultPayload` to a `(status, error)` pair. Order matters: a result with both `error` and `interrupts` prefers the interrupt classification, since `GraphInterrupt` manifests as a populated `interrupts` list, not as `error`. r?rr8r)rN)rAr)rr8s r-rrOs9{{<  " KK E U## r/c^\rSrSrSrSrS S U4SjjjrS SjrS SjrSSjr SSjr S r U=r $)LifecycleTransformeri`uSurface subgraph lifecycle as `lifecycle` protocol events. Pushes `LifecyclePayload` to a `StreamChannel` named `lifecycle`. The channel is auto-forwarded by the mux so payloads land in the main event log under `method = "lifecycle"` (native transformer — no `custom:` prefix) — visible to remote SDK clients over the wire and to in-process consumers via `run.lifecycle`. Tracks subgraphs at every depth strictly below the transformer's scope, so a graph → subgraph → subgraph chain produces lifecycle events for both nested levels in a flat stream. Native transformer — projection key `lifecycle` is exposed as `run.lifecycle`. TcD>[TU]U5 [S5UlgN lifecycle)r!r"r_channelr)s r-r"LifecycleTransformer.__init__ss 9F{9S r/cSUR0$rr!r2s r-r3LifecycleTransformer.initwsT]]++r/cz[UR5n[U5U:=(a USUUR:H$ralenr+r*rdepths r-r"LifecycleTransformer._should_trackzs1DJJ2w;2fu:#;;r/cUcgS[U5S.nU(aX$S'X4S'URnUbXTS'URRU5 g)NrrDr=rrr)r'rr!rC)r*rrrrrs r-r LifecycleTransformer._on_started~s\  " .7d2h$O $.L !%4!"##  $G  7#r/cdU[U5S.nUbX4S'URRU5 g)Nr-r8)r'r!rC)r*rrr8rs r-r!LifecycleTransformer._on_terminals2 /548$L  $G  7#r/r$rGrHrLrrr) rQrRrSrTrUrVr"r3rrrrYrZr[s@r-rr`s GTT,<$ $$$ $  $( $  $ $ $  $ $r/rc^^\rSrSrSrSrSrSSU4SjjjrSSjrSSjr SSjr SSjr SS jr SS jr SS jrS S jrS S jrS!SjrS"U4SjjrS"SjrS#SjrS#SjrS$SjrS$SjrS%SjrS%SjrSrU=r$)&SubgraphTransformeriuDiscover subgraph invocations as in-process navigation handles. Per discovered direct-child subgraph, builds a `SubgraphRunStream` (or `AsyncSubgraphRunStream`) wrapping a child mini-mux scoped to the subgraph's namespace. Consumers iterate `run.subgraphs` to receive handles, then drill into `handle.values` / `handle.messages` / `handle.subgraphs` (recursive grandchildren) / `handle.lifecycle`. Each mini-mux owns its own scope and uses its own `SubgraphTransformer` to discover its direct children, so grandchildren live on the child handle — never on the root's `subgraphs` log. Forwarding events into the matching child mini-mux is what keeps the child's projections populated. Native transformer — `subgraphs` is exposed as `run.subgraphs`. Tc^>[TU]U5 [5Ul0UlSUlgra)r!r"rr#_handles_muxr)s r-r"SubgraphTransformer.__init__s1  O  '+ r/cSUR0$)N subgraphsr1r2s r-r3SubgraphTransformer.initsTYY''r/cXlgra)r5)r*muxs r- _on_register SubgraphTransformer._on_registers r/c[UR5n[U5US-:H=(a USUUR:H$)Nr'r)s r-r!SubgraphTransformer._should_tracks8DJJ2w%!)#@6E djj(@@r/cURcgURRU5nUR(a[O[ nU"UUUUS9nX`R U'URRU5 g![a gf=f)N)r;pathrr) r5 _make_child RuntimeErroris_asyncrrr4r#rC)r*rrr child_mux handle_clshandles r-rSubgraphTransformer._on_starteds 99    --b1I09/A/A+GX !+   # b v   sA;; BBcURRU5nUbURXBU5(dgURXBU5 gra)r4rA_mark_terminal_close_or_fail_handler*rrr8rHs r-r SubgraphTransformer._on_terminalsB ""2& >!4!4VU!K!K  ""659r/c# URRU5nUbURXBU5(dgURXBU5IShvN gN7fra)r4rArK_aclose_or_fail_handlerMs r- _aon_terminal!SubgraphTransformer._aon_terminalsK ""2& >!4!4VU!K!K ))&%@@@sA AAAcnUR(agX!lUbURcX1lSUlg)z>Mark a handle terminal once. Returns True on first transition.FT)_seen_terminalrr8r*rHrr8s r-rK"SubgraphTransformer._mark_terminals4    !5 L $r/cURb%URRR(agUS:Xa.URR[ U=(d S55 gURR 5 gNrzSubgraph failed)r5_events_closedrrDcloserUs r-rL)SubgraphTransformer._close_or_fail_handlesX ;; &++"5"5"="=  X  KK  \%*D3DE F KK   r/c6# URb%URRR(agUS:Xa6URR[ U=(d S55IShvN gURR 5IShvN gN(N7frX)r5rYrZafailrDacloserUs r-rP*SubgraphTransformer._aclose_or_fail_handlesp ;; &++"5"5"="=  X ++##L1K:K$LM M M++$$& & & N &s$A*B,B-"BBBBc&[USS5n[UR5n[U5US-:agURR USUS-5nUb2UR b%UR R R(agU$)Nr<r=r?)rr(r+r4rAr5rYrZ)r*rDrr*rHs r-_handle_for_event%SubgraphTransformer._handle_for_event!s}5?;/ 0DJJ r7UQY ""2k ?3 >V[[0FKK4G4G4O4O r/c>[TU]U5nURU5nUb,URU5 URR U5 U$ra)r!rErb_observe_eventr5rC)r*rDkeeprHr,s r-rESubgraphTransformer.process-sNwu%''.    ! !% ( KK  U # r/c# USS:Xa[USS5nUSSnSU;a6URX#5H upEnURXEU5IShvN M" O3URX#5 UR U5 UR X#5 SnOSnUR U5nUb4URU5 URRU5IShvN U$NN7f) Nr;rr<r=r>rFT) rr rQrrrrbrer5apush) r*rDrr>r rr8rfrHs r-aprocessSubgraphTransformer.aprocess7s ?g %uX{34B?6*D4/3/M/Mb/W+He,,XuEEE0X %%b///5''1DD''.    ! !% (++##E* * * F +s%AC'C#BC'C%C'%C'cSn[UR5HnURUSS5 M URR 5 UR R 5H1nURUSS5(dMURUSS5 M3 U$![anUcUnSnAMSnAMSnAff=f![anUcUnSnAMoSnAMuSnAff=fNr) r'rrrrr4rrKrLr* first_errorrerHs r-_complete_open_handles*SubgraphTransformer._complete_open_handlesPs,0 tzz"B $!!"k48# mm**,F""6;==(..v{DI-! $&"#K' $%("*&' +(s/BC B>(B99B> C! CC!c# Sn[UR5HnURUSS5IShvN M! URR 5 UR R 5H9nURUSS5(dMURUSS5IShvN M; U$N{![anUcUnSnAMSnAMSnAff=fN/![anUcUnSnAM{SnAMSnAff=f7frm) r'rrQrrr4rrKrPrns r-_acomplete_open_handles+SubgraphTransformer._acomplete_open_handlesbs,0 tzz"B $(([$???# mm**,F""6;==(55fk4PPP-@  $&"#K' $Q$("*&' +(szC:B2B0B2AC:C%C&C*C:0B22 C<C  C: CC:C C7!C2& C:2C77C:c.UR5nUbUegra)rqr*ros r-rSubgraphTransformer.finalizets!113  "  #r/cJ# UR5IShvN nUbUegN 7fra)rtrws r- afinalizeSubgraphTransformer.afinalizeys, 88::  "  #;s #! #c[U5up#URR5 URR 5HgnUR XBU5 UR cM$UR RR(aMKUR RU5 Mi g![a# [RSURSS9 Mf=fNzRError failing subgraph mini-mux at %s; subscribers may not see the terminal error.T)exc_info)rrrr4rrKr5rYrZr Exception_loggerwarningrBr*rrrrHs r-rSubgraphTransformer.fail~s237 mm**,F    :{{&v{{/B/B/J/J/JKK$$S) - !OOF !% $sB..)CCc# [U5up#URR5 URR 5HonUR XBU5 UR cM$UR RR(aMKUR RU5IShvN Mq gN ![a# [RSURSS9 Mf=f7fr})rrrr4rrKr5rYrZr^rrrrBrs r-r^SubgraphTransformer.afails237 mm**,F    :{{&v{{/B/B/J/J/J ++++C000 -1 OOF !% $sBA"C*(#C*B:.B8/B:3C*8B::)C'#C*&C''C*)r4r#r5rGrHrL)r;rrJrKrrr)rH*SubgraphRunStream | AsyncSubgraphRunStreamrrr8rrJrP)rHrrrr8rrJrK)rDrrJz1SubgraphRunStream | AsyncSubgraphRunStream | NonerOrNrr)rQrRrSrTrUrV supports_syncr"r3r<rrrrQrKrLrPrbrErjrqrtrrzrr^rYrZr[s@r-r2r2sw"GM++(A  $   2 :  : : :  : A  A A A  A :       :         ': ' ' '  ' "  : 2$$   r/r2cP^\rSrSrSrSrSrS S U4SjjjrS SjrS Sjr Sr U=r $) CheckpointsTransformeriu]Capture checkpoint events as a drainable stream. Surfaces `stream_mode="checkpoints"` data on `run.checkpoints` as a `StreamChannel[dict[str, Any]]`. Each item is in the same format as returned by `get_state()`. Checkpoint events are only emitted when a checkpointer is configured on the graph. When no checkpointer is present, the projection exists but receives no events. Only events at the run's own scope are captured; checkpoint data from deeper subgraphs is available on the respective subgraph handle's `.checkpoints` projection. Native transformer — `run.checkpoints` is a direct attribute. T) checkpointscb>[TU]U5 [5Ul[ U5Ulgrarbr)s r-r"CheckpointsTransformer.__init__rrr/cSUR0$)Nrr1r2s r-r3CheckpointsTransformer.initstyy))r/cUSS:wagUSnUSUR:wagURRUS5 g)Nr;rTr<r=r>rgrhs r-rECheckpointsTransformer.processsG ?m +x + $"2"2 2 vf~&r/rjrGrHrLrOrkr[s@r-rrs."G,22 *r/rcP^\rSrSrSrSrSrS S U4SjjjrS SjrS Sjr Sr U=r $) DebugTransformeriuCapture debug events as a drainable stream. Surfaces `stream_mode="debug"` data on `run.debug` as a `StreamChannel[dict[str, Any]]`. Each item is a debug event with step-level detail (checkpoint snapshots, task payloads, and task results wrapped with step number and timestamp). Only events at the run's own scope are captured; debug data from deeper subgraphs is available on the respective subgraph handle's `.debug` projection. Native transformer — `run.debug` is a direct attribute. T)debugcb>[TU]U5 [5Ul[ U5Ulgrarbr)s r-r"DebugTransformer.__init__rrr/cSUR0$)Nrr1r2s r-r3DebugTransformer.init##r/cUSS:wagUSnUSUR:wagURRUS5 g)Nr;rTr<r=r>rgrhs r-rEDebugTransformer.processG ?g %x + $"2"2 2 vf~&r/rjrGrHrLrOrkr[s@r-rrs. G&22 $r/rcP^\rSrSrSrSrSrS S U4SjjjrS SjrS Sjr Sr U=r $) TasksTransformeriukCapture raw task events as a drainable stream. Surfaces `stream_mode="tasks"` data on `run.tasks` as a `StreamChannel[dict[str, Any]]`. Each item is a task payload (start or result). `LifecycleTransformer` and `SubgraphTransformer` also consume `tasks` events for subgraph discovery and lifecycle tracking. This transformer captures the raw payloads independently for consumers who need task-level detail. Only events at the run's own scope are captured; task data from deeper subgraphs is available on the respective subgraph handle's `.tasks` projection. Native transformer — `run.tasks` is a direct attribute. Trcb>[TU]U5 [5Ul[ U5Ulgrarbr)s r-r"TasksTransformer.__init__rrr/cSUR0$)Nrr1r2s r-r3TasksTransformer.initrr/cUSS:wagUSnUSUR:wagURRUS5 g)Nr;rTr<r=r>rgrhs r-rETasksTransformer.processrr/rjrGrHrLrOrkr[s@r-rrs.$G&22 $r/r)rrrJztuple[str, str | None])rrrJ!tuple[SubgraphStatus, str | None])rrMrJr)9 __future__rloggingtypingrrrr-langchain_core.language_models._compat_bridger0langchain_core.language_models.chat_model_streamr r langchain_core.messagesr r r langchain_protocol.protocolrrtyping_extensionsrrlanggraph.errorsrrlanggraph.stream._typesrrlanggraph.stream.run_streamrrlanggraph.stream.stream_channelrcollections.abcrrlanggraph.stream._muxr getLoggerrQrrr]rmrxrrrrrrrr2rrrr@r/r-rs"44KMLD49DQ93/   H %6)6r ) F * Fy#+y#xST*y"N+Nb &";$.;$|~-~B$.$N!(!H%(%r/