tj/^ddlmZddlZddlmZmZmZmZddlm Z ddl m Z m Z ddl mZmZmZddlmZmZddlmZmZdd lmZmZdd lmZmZdd lmZmZdd l m!Z!erdd l"m#Z#m$Z$ddl%m&Z&ej'e(Z)GddeZ*GddeZ+GddeZ,GddeZ-edZ.d4dZ/Gdded Z0Gd!d"eZ1d5d&Z2d6d)Z3Gd*d+e1Z4Gd,d-e1Z5Gd.d/eZ6Gd0d1eZ7Gd2d3eZ8dS)7) annotationsN) TYPE_CHECKINGAnyLiteralcast)message_to_events)AsyncChatModelStreamChatModelStream)AIMessageChunk BaseMessage ToolMessage)LifecycleCause MessagesData) NotRequired TypedDict) GraphDrainedGraphInterrupt) ProtocolEventStreamTransformer)AsyncSubgraphRunStreamSubgraphRunStream) StreamChannel) AwaitableCallable) StreamMuxcVeZdZdZdZdZddfd Zdd Zedd Z ddZ xZ S)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)valuesscopetuple[str, ...]returnNonect|t|_d|_d|_g|_t||_dS)NF) super__init__r_log_latest _interrupted _interruptslist _scope_listselfr __class__s [/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/langgraph/stream/transformers.pyr&zValuesTransformer.__init__1sS 3@?? .2 !&('+5kkdict[str, Any]cd|jiS)Nrr'r.s r0initzValuesTransformer.init;$)$$r1BaseException | Nonec|jjS)zThe error that ended the run, or `None` if it succeeded. Set by the mux when it auto-fails the projection log. )r'_errorr5s r0errorzValuesTransformer.error>s yr1eventrboolc$|ddkrdS|d}|d|jkrdS|d|_|dd}|r!d|_|j||j|ddS) NmethodrTparams namespacedata interruptsr)r,r(getr)r*extendr'push)r.r<r@rCs r0processzValuesTransformer.processFs ?h & &4x + $"2 2 24f~ ZZ b11  0 $D    # #J / / / vf~&&&tr1rr r!r"r#r"r2r"r8r<rr"r=) __name__ __module__ __qualname____doc___nativerequired_stream_modesr&r6propertyr;rG __classcell__r/s@r0rrs"G'2222222%%%%   X         r1rc>eZdZdZdZdZddfd Zdd ZddZxZ S)CustomTransformeruCapture 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)customrr r!r"r#ct|t|_t ||_dSNr%r&rr'r+r,r-s r0r&zCustomTransformer.__init__fs: (5 &*5kkr1r2cd|jiS)NrXr4r5s r0r6zCustomTransformer.initkr7r1r<rr=c|ddkrdS|d}|d|jkrdS|j|ddS)Nr?rXTr@rArBr,r'rFr.r<r@s r0rGzCustomTransformer.processnsT ?h & &4x + $"2 2 24 vf~&&&tr1rHrIrJrL rMrNrOrPrQrRr&r6rGrTrUs@r0rWrWUs  G'2222222 %%%%r1rWc>eZdZdZdZdZddfd Zdd ZddZxZ S)UpdatesTransformeruCapture 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)updatesrr r!r"r#ct|t|_t ||_dSrZr[r-s r0r&zUpdatesTransformer.__init__: 3@?? &*5kkr1r2cd|jiS)Nrcr4r5s r0r6zUpdatesTransformer.inits49%%r1r<rr=c|ddkrdS|d}|d|jkrdS|j|ddS)Nr?rcTr@rArBr^r_s r0rGzUpdatesTransformer.processsT ?i ' '4x + $"2 2 24 vf~&&&tr1rHrIrJrLr`rUs@r0rbrbxs  G(2222222 &&&&r1rbcveZdZdZdZdZd'd(fd Zd)d Zd*dZd+dZ d,dZ d-dZ d.dZ d/d"Z d0d#Zd1d&ZxZS)2MessagesTransformeru>Capture 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)messagesrr r!r"r#ct|t|_i|_t |_d|_d|_t||_ dSrZ) r%r&rr'_by_runset _ignored_runs_pump_fn _apump_fnr+r,r-s r0r&zMessagesTransformer.__init__s_ 4AOO 46 '*uu37 ?C'+5kkr1r2cd|jiS)Nrjr4r5s r0r6zMessagesTransformer.initsDI&&r1fnCallable[[], bool]c||_dS)zIWire the sync pull callback. Called by GraphRunStream._wire_request_more.N)ror.rrs r0 _bind_pumpzMessagesTransformer._bind_pumps  r1Callable[[], Awaitable[bool]]c||_dS)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)rprus r0 _bind_apumpzMessagesTransformer._bind_apumpsr1rA list[str]node str | None message_idr c|j.t|||}||j|S|j.t |||}||j|St|||S)a^Create 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. NrAr{r})rpr set_arequest_moreror set_request_more)r.rAr{r}astreamstreams r0 _make_streamz MessagesTransformer._make_streams > %*#%G  % %dn 5 5 5N = $&5#%'''F  # #DM 2 2 2M#!    r1r<rr=c|ddkrdS|d}|d|jkrdS|d\}}|d}|r#t|dd nd }t|tr+d |vr'|t d ||| nVt|trAt|ts,t|ts| || dS)Nr?rjTr@rArBlanggraph_noderun_idr<r)rr{)r{) r,rDstr isinstancedict_route_protocol_eventrr r r _route_whole_message)r.r<r@payloadmetadatar{rs r0rGzMessagesTransformer.process s' ?j ( (4x + $"2 2 24"6N#<<(8994<DX\\(B//000" gt $ $ :G););  & &^W--f4 '     w , , :w77 :w 44 :  % %gD % 9 9 9 tr1rrrcl|d}|dkr|ddkr|j|dS|d}|g||t |nd}||j|<|j|||dS||jvr$|dkr|j |dSdS||jvr2|j|}|||dkr |j|=dSdSdS)Nr<z message-startroletoolr}rzmessage-finish) rDrnaddrrrlr'rFdispatchdiscard)r.r<rr{ event_typer}rs r0rz)MessagesTransformer._route_protocol_event$shYYw''  ( (yy  F**"&&v...<00J&&.8.D3z???$'F $*DL INN6 " " " OOE " " " " " t) ) )---"**622222.- t| # #\&)F OOE " " "---L((( $ #.-r1messager c|g||j}t||jD]}|||j|dS)Nr)r})ridrrr'rF)r.rr{revts r0rz(MessagesTransformer._route_whole_messageDsk""Rdwz"RR$WDDD ! !C OOC  vr1cj|j|jdS)uJClear any routing state — streams close themselves via `message-finish`.N)rlclearrnr5s r0finalizezMessagesTransformer.finalizeJs1    """""r1err BaseExceptionct|jD]}|||j|jdS)zCPropagate run error to any streams still open when the graph fails.N)r+rlrfailrrn)r.rrs r0rzMessagesTransformer.failOsk4<..0011  F KK        """""r1rHrIrJ)rrrsr"r#)rrrwr"r#)rArzr{r|r}r|r"r rL)r<rrrr{r|r"r#)rr r{r|r"r#r"r#rrr"r#)rMrNrOrPrQrRr&r6rvryrrGrrrrrTrUs@r0riris''RG) 2 2 2 2 2 2 2''''" " " " H6))))@ #### ########r1ri)started completedfailed interrupteddrainedsegmentrr"tuple[str, str | None]cD|d\}}}||r|ndfS)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)rnameseptask_ids r0_parse_ns_segmentrZs2 !**3//D#w C)T ))r1cPeZdZUdZded<ded<ded<ded<d ed <ded <d S) LifecyclePayloada,Payload 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`. SubgraphStatusr<rzrAzNotRequired[str] graph_nametrigger_call_idzNotRequired[LifecycleCause]causer;N)rMrNrOrP__annotations__rr1r0rrdsf    %%%%&&&&r1rF)totalceZdZdZdZd#d$fd Zd%d Zd&dZd'dZd(dZ d)dZ d*dZ d)dZ d+dZ d)dZd,dZd-d"ZxZS)._TasksLifecycleBaseu Shared 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. tasksrr r!r"r#ct|t|_i|_i|_i|_d|_dSrZ)r%r&rm_seen_open _lc_by_ns_pending_tool_calls_pending_causer-s r0r&z_TasksLifecycleBase.__init__sR +.55 24 =? 46 6:r1nsr=ct)uFScope filter — return True iff `ns` is in this transformer's region.NotImplementedErrorr.rs r0 _should_trackz!_TasksLifecycleBase._should_tracks!!r1rr|rct)zFired once per discovered namespace (first observed task event). The triggering `cause` (if any) is available as `self._pending_cause`. r)r.rrrs r0 _on_startedz_TasksLifecycleBase._on_starteds "!r1statusrr;ct)z{Fired once per tracked namespace when its parent's result arrives, or via finalize/fail safety-net sweeps. r)r.rrr;s r0 _on_terminalz _TasksLifecycleBase._on_terminals "!r1r<rc,|ddkrdSt|dd}|dd}d|vr|||nA||||||||dS) Nr?rTr@rArBresultF)tuple_handle_task_result_record_identity_record_pending_tool_calls_handle_task_start)r.r<rrBs r0rGz_TasksLifecycleBase.processs ?g % %4 5?;/ 0 0Xv& t    $ $R . . . .  ! !"d + + +  + +D 1 1 1  # #B - - -ur1rBr2c||jvrdS|dpi}|d|j|<dS)ayRecord 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)rrD)r.rrBrs r0rz$_TasksLifecycleBase._record_identitysJ    F88J''-2%\\/::rr1cJ|d}t|tsdS|d}d}t|tr[t|dtr3|dd}t|tr|}nat|trL|D]I}t|tr2t|dtr |d}nJ| ||j|<dSdS)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)rDrrrr+r)r.rBrr tool_call_id candidatetcs r0rz._TasksLifecycleBase._record_pending_tool_callss((4..'3''  F((7###'  gt $ $ GKK 4L4Ld)S)S  ,0066I)S)) )(  & &   b$''Jrvvd||S,I,I#%d8LE  #0Return and remove tracked children closed by this task result.rNr)rDr+ritems_terminal_from_resultappend) r.rrB result_id transitionschild_nsparent_task_idrr;s r0_pop_terminal_transitionsz-_TasksLifecycleBase._pop_terminal_transitions$sHHTNN  IPR (,TZ-=-=-?-?(@(@ % % $Hn}""n &A&A1$77MFE   &%8 9 9 9 8$$r1cn|||D]\}}}||||dSrZ)rr)r.rrBrrr;s r0rz'_TasksLifecycleBase._handle_task_result4sM'+'E'Eb$'O'O 7 7 #Hfe   h 6 6 6 6 7 7r1ct|jD]}||dd|jdS)zAEmit `completed` for any tracked namespace still open at run end.rN)r+rrrrs r0rz_TasksLifecycleBase.finalize8sPtz"" 5 5B   b+t 4 4 4 4 r1rrct|\}}t|jD]}|||||jdS)z:Emit terminal status for any tracked namespace still open.N)_status_from_exceptionr+rrr)r.rr error_strrs r0rz_TasksLifecycleBase.fail>sb2377 tz"" 5 5B   b&) 4 4 4 4 r1rHrIrr!r"r=rr!rr|rr|r"r#rr!rrr;r|r"r#rL)rr!rBr2r"r#)rBr2r"r#)rr!rBr2r"rrr)rMrNrOrPrRr&rrrrGrrrrrrrrTrUs@r0rrus08':::::::4"""" " " " " " " " " ; ; ; ;====<----< 7777 r1rrr!tuple[SubgraphStatus, str | None]ct|trdSt|trdSdt|fS)zCMap a run exception to a subgraph terminal status and error string.)rNrNr)rrrr)rs r0rrFsB#|$$#~&&#"" SXX r1rr2c|drdS|d}|rdt|fSdS)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`. rCrr;r)rN)rDr)rr;s r0rrOsN{{<  #"" KK E $U##  r1cJeZdZdZdZddfd Zdd Zdd ZddZddZ xZ S)LifecycleTransformeruSurface 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`. Trr r!r"r#crt|td|_dSN lifecycle)r%r&r_channelr-s r0r&zLifecycleTransformer.__init__ss. 9F{9S9S r1r2cd|jiSr)rr5s r0r6zLifecycleTransformer.initwsT]++r1rr=cvt|j}t||ko|d||jkSrZlenr r.rdepths r0rz"LifecycleTransformer._should_trackzs3DJ2ww;2fuf:#;;r1rr|rc|dSdt|d}|r||d<||d<|j}|||d<|j|dS)Nrr<rArrr)r+rrrF)r.rrrrrs r0rz LifecycleTransformer._on_started~su  " F.7d2hh$O$O  /$.GL !%4!"#  $GG  7#####r1rrr;cl|t|d}|||d<|j|dS)Nrr;)r+rrF)r.rrr;rs r0rz!LifecycleTransformer._on_terminalsC /5488$L$L  $GG  7#####r1rHrIrJrrr) rMrNrOrPrQr&r6rrrrTrUs@r0rr`s GTTTTTTT,,,,<<<<$$$$( $ $ $ $ $ $ $ $r1rceZdZdZdZdZd.d/fd Zd0d Zd1d Zd2dZ d3dZ d4dZ d4dZ d5dZ d6dZd6dZd7d"Zd8fd# Zd8d$Zd9d&Zd9d'Zd:d(Zd:d)Zd;d,Zd;d-ZxZS)<SubgraphTransformeru#Discover 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`. Trr r!r"r#ct|t|_i|_d|_dSrZ)r%r&rr'_handles_muxr-s r0r&zSubgraphTransformer.__init__sB  OO  '+ r1r2cd|jiS)N subgraphsr4r5s r0r6zSubgraphTransformer.initsTY''r1muxrc||_dSrZ)r)r.rs r0 _on_registerz SubgraphTransformer._on_registers  r1rr=c|t|j}t||dzko|d||jkS)Nrrs r0rz!SubgraphTransformer._should_tracks:DJ2ww%!)#@6E6 dj(@@r1rr|rc|jdS |j|}n#t$rYdSwxYw|jrtnt }|||||}||j|<|j|dS)N)rpathrr) r _make_child RuntimeErroris_asyncrrr r'rF)r.rrr child_mux handle_clshandles r0rzSubgraphTransformer._on_starteds 9  F  --b11II    FF /8/AX++GX !+     # b vs & 44rrr;c|j|}|||||sdS||||dSrZ)r rD_mark_terminal_close_or_fail_handler.rrr;rs r0rz SubgraphTransformer._on_terminalsW ""2&& >!4!4VVU!K!K> F ""66599999r1cK|j|}|||||sdS||||d{VdSrZ)r rDr_aclose_or_fail_handler!s r0 _aon_terminalz!SubgraphTransformer._aon_terminalsm ""2&& >!4!4VVU!K!K> F))&&%@@@@@@@@@@@r1r*SubgraphRunStream | AsyncSubgraphRunStreamcT|jrdS||_||j||_d|_dS)z>Mark a handle terminal once. Returns True on first transition.FNT)_seen_terminalrr;r.rrr;s r0rz"SubgraphTransformer._mark_terminals<   5  !5 FL $tr1c|j|jjjrdS|dkr+|jt |pddS|jdSNrzSubgraph failed)r_events_closedrrcloser(s r0r z)SubgraphTransformer._close_or_fail_handlesm ; &+"5"=  F X   K  \%*D3DEE F F F F F K       r1cK|j|jjjrdS|dkr1|jt |pdd{VdS|jd{VdSr*)rr+r,afailracloser(s r0r#z*SubgraphTransformer._aclose_or_fail_handles ; &+"5"=  F X  +##L1K:K$L$LMM M M M M M M M M M+$$&& & & & & & & & & &r1r<r1SubgraphRunStream | AsyncSubgraphRunStream | Nonect|dd}t|j}t||dzkrdS|j|d|dz}||j|jjjrdS|S)Nr@rAr)rrr r rDrr+r,)r.r<rrrs r0_handle_for_eventz%SubgraphTransformer._handle_for_event!s5?;/ 0 0DJ r77UQY  4""2k k?33 >V[0FK4G4O04 r1ct|}||}|/|||j||SrZ)r%rGr3_observe_eventrrF)r.r<keeprr/s r0rGzSubgraphTransformer.process-sbwwu%%''..    ! !% ( ( ( K  U # # # r1cK|ddkrt|dd}|dd}d|vr;|||D]#\}}}||||d{V$nA||||||||d}nd}||}|5|||j |d{V|S) Nr?rr@rArBrFT) rrr$rrrr3r5rapush) r.r<rrBrrr;r6rs r0aprocesszSubgraphTransformer.aprocess7sJ ?g % %uX{344B?6*D4/3/M/MbRV/W/WFF+Hfe,,XvuEEEEEEEEEEF %%b$/////555''D111DDD''..    ! !% ( ( (+##E** * * * * * * * r1r8cd}t|jD]5} ||dd#t$r}||}Yd}~.d}~wwxYw|j|jD]M}||ddr4 ||dd2#t$r}||}Yd}~Ed}~wwxYwN|SNr) r+rrrrr rrr r. first_errorrers r0_complete_open_handlesz*SubgraphTransformer._complete_open_handlesPs,0 tz"" $ $B $!!"k48888  $ $ $&"#K $ m**,, ( (F""6;== ((..v{DIIII$((("*&' ( ( s,2 A AA B11 C ;CC cKd}t|jD];} ||ddd{V!#t$r}||}Yd}~4d}~wwxYw|j|jD]S}||ddr: ||ddd{V8#t$r}||}Yd}~Kd}~wwxYwT|Sr;) r+rr$rrr rrr#r<s r0_acomplete_open_handlesz+SubgraphTransformer._acomplete_open_handlesbs@,0 tz"" $ $B $(([$??????????  $ $ $&"#K $ m**,, ( (F""6;== ((55fk4PPPPPPPPPP$((("*&' ( ( s-: AA  A!B?? C CCc6|}||dSrZ)r?r.r=s r0rzSubgraphTransformer.finalizets'1133  "  # "r1cFK|d{V}||dSrZ)rArCs r0 afinalizezSubgraphTransformer.afinalizeys= 88::::::::  "  # "r1rrct|\}}|j|jD]}|||||j_|jjjsN |j |M#t$r%t d|j dY{wxYwdSNzRError failing subgraph mini-mux at %s; subscribers may not see the terminal error.T)exc_info)rrrr rrrr+r,r Exception_loggerwarningrr.rrrrs r0rzSubgraphTransformer.fail~s2377  m**,,  F    : : :{&v{/B/J&K$$S)))) OOF !% $  s7B,CCcKt|\}}|j|jD]}|||||je|jjjsT |j |d{VS#t$r%t d|j dYwxYwdSrG)rrrr rrrr+r,r/rIrJrKrrLs r0r/zSubgraphTransformer.afails2377  m**,,  F    : : :{&v{/B/J& +++C0000000000 OOF !% $  s9 B,C C rHrIrJ)rrr"r#rrr)rr%rrr;r|r"r=)rr%rrr;r|r"r#)r<rr"r1rLrKrr)rMrNrOrPrQ supports_syncr&r6rrrrr$rr r#r3rGr9r?rArrErr/rTrUs@r0r r s"GM+++++++((((AAAA 2 : : : : A A A A          ' ' ' '    2$$   r1r c>eZdZdZdZdZddfd Zdd ZddZxZ S)CheckpointsTransformeruCapture 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) checkpointsrr r!r"r#ct|t|_t ||_dSrZr[r-s r0r&zCheckpointsTransformer.__init__rer1r2cd|jiS)NrQr4r5s r0r6zCheckpointsTransformer.initsty))r1r<rr=c|ddkrdS|d}|d|jkrdS|j|ddS)Nr?rQTr@rArBr^r_s r0rGzCheckpointsTransformer.processsT ?m + +4x + $"2 2 24 vf~&&&tr1rHrIrJrLr`rUs@r0rPrPs"G,2222222 ****r1rPc>eZdZdZdZdZddfd Zdd ZddZxZ S)DebugTransformeruCapture 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)debugrr r!r"r#ct|t|_t ||_dSrZr[r-s r0r&zDebugTransformer.__init__rer1r2cd|jiS)NrWr4r5s r0r6zDebugTransformer.init##r1r<rr=c|ddkrdS|d}|d|jkrdS|j|ddS)Nr?rWTr@rArBr^r_s r0rGzDebugTransformer.processT ?g % %4x + $"2 2 24 vf~&&&tr1rHrIrJrLr`rUs@r0rVrVs  G&2222222 $$$$r1rVc>eZdZdZdZdZddfd Zdd ZddZxZ S)TasksTransformeruCapture 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. Trrr r!r"r#ct|t|_t ||_dSrZr[r-s r0r&zTasksTransformer.__init__rer1r2cd|jiS)Nrr4r5s r0r6zTasksTransformer.initrZr1r<rr=c|ddkrdS|d}|d|jkrdS|j|ddS)Nr?rTr@rArBr^r_s r0rGzTasksTransformer.processr\r1rHrIrJrLr`rUs@r0r^r^s$G&2222222 $$$$r1r^)rrr"r)rrr"r)rr2r"r)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 getLoggerrMrJrrWrbrirrrrrrrr rPrVr^rr1r0rqs""""""444444444444KKKKKKMLLLLLLLLLDDDDDDDD4444444499999999DDDDDDDDQQQQQQQQ999999033333333////// ' H % %66666)666r     )   F     *   Fy#y#y#y#y#+y#y#y#xST****y"NNNNN+NNNb";$;$;$;$;$.;$;$;$|~~~~~-~~~B$$$$$.$$$N!!!!!(!!!H%%%%%(%%%%%r1