Ë
    òÏj/Ÿ  ã                  ó   — d dl mZ d dlZd dlmZmZmZmZ d dlm	Z	 d dl
mZmZ d dlmZmZmZ d dlmZmZ d dlmZmZ d d	lmZmZ d d
lmZmZ d dlmZmZ d dl m!Z! erd dl"m#Z#m$Z$ d dl%m&Z&  ejN                  e(«      Z) G d„ de«      Z* G d„ de«      Z+ G d„ de«      Z, G d„ de«      Z-ed   Z.d+d„Z/ G d„ ded¬«      Z0 G d„ de«      Z1d,d„Z2	 	 	 	 d-d „Z3 G d!„ d"e1«      Z4 G d#„ d$e1«      Z5 G d%„ d&e«      Z6 G d'„ d(e«      Z7 G d)„ d*e«      Z8y).é    )ÚannotationsN)ÚTYPE_CHECKINGÚAnyÚLiteralÚcast)Úmessage_to_events)ÚAsyncChatModelStreamÚChatModelStream)ÚAIMessageChunkÚBaseMessageÚToolMessage)ÚLifecycleCauseÚMessagesData)ÚNotRequiredÚ	TypedDict)ÚGraphDrainedÚGraphInterrupt)ÚProtocolEventÚStreamTransformer)ÚAsyncSubgraphRunStreamÚSubgraphRunStream)ÚStreamChannel)Ú	AwaitableÚCallable)Ú	StreamMuxc                  óP   ‡ — e Zd ZdZdZdZdd	ˆ fd„Zd
d„Zedd„«       Z	dd„Z
ˆ xZS )ÚValuesTransformeru  Capture 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                óŒ   •— t         ‰| �  |«       t        «       | _        d | _        d| _        g | _        t        |«      | _        y )NF)	ÚsuperÚ__init__r   Ú_logÚ_latestÚ_interruptedÚ_interruptsÚlistÚ_scope_list©ÚselfÚscopeÚ	__class__s     €úZ/var/www/html/gaurav-v2/venv/lib/python3.12/site-packages/langgraph/stream/transformers.pyr!   zValuesTransformer.__init__1   s>   ø€ Ü‰Ñ˜ÔÜ3@³?ˆŒ	Ø.2ˆŒØ!ˆÔØ&(ˆÔô '+¨5£kˆÕó    c                ó   — d| j                   iS )Nr   ©r"   ©r)   s    r,   ÚinitzValuesTransformer.init;   ó   € Ø˜$Ÿ)™)Ð$Ð$r-   c                ó.   — | j                   j                  S )z€The error that ended the run, or `None` if it succeeded.

        Set by the mux when it auto-fails the projection log.
        )r"   Ú_errorr0   s    r,   ÚerrorzValuesTransformer.error>   s   € ð �y‰y×ÑÐr-   c                ó  — |d   dk7  ry|d   }|d   | j                   k7  ry|d   | _        |j                  dd«      }|r"d| _        | j                  j                  |«       | j                  j                  |d   «       y)	NÚmethodr   TÚparamsÚ	namespaceÚdataÚ
interrupts© )r'   r#   Úgetr$   r%   Úextendr"   Úpush)r)   Úeventr8   r;   s       r,   ÚprocesszValuesTransformer.processF   s�   € Ø�‰?˜hÒ&ØØ�x‘ˆØ�+Ñ $×"2Ñ"2Ò2ØØ˜f‘~ˆŒØ—Z‘Z ¨bÓ1ˆ
ÙØ $ˆDÔØ×Ñ×#Ñ# JÔ/Ø�	‰	�‰�v˜f‘~Ô&Ør-   ©r<   ©r*   útuple[str, ...]ÚreturnÚNone©rE   údict[str, Any]©rE   zBaseException | None©r@   r   rE   Úbool)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú_nativeÚrequired_stream_modesr!   r1   Úpropertyr5   rA   Ú__classcell__©r+   s   @r,   r   r      s8   ø„ ñð" €GØ'Ðö2ó%ð ò ó ð ÷r-   r   c                  ó>   ‡ — e Zd ZdZdZdZddˆ fd„Zd	d„Zd
d„Zˆ xZ	S )ÚCustomTransformeruå  Capture 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)Úcustomc                ób   •— t         ‰| �  |«       t        «       | _        t	        |«      | _        y ©N©r    r!   r   r"   r&   r'   r(   s     €r,   r!   zCustomTransformer.__init__f   s%   ø€ Ü‰Ñ˜ÔÜ(5«ˆŒ	Ü&*¨5£kˆÕr-   c                ó   — d| j                   iS )NrW   r/   r0   s    r,   r1   zCustomTransformer.initk   r2   r-   c                ó‚   — |d   dk7  ry|d   }|d   | j                   k7  ry| j                  j                  |d   «       y)Nr7   rW   Tr8   r9   r:   ©r'   r"   r?   ©r)   r@   r8   s      r,   rA   zCustomTransformer.processn   sG   € Ø�‰?˜hÒ&ØØ�x‘ˆØ�+Ñ $×"2Ñ"2Ò2ØØ�	‰	�‰�v˜f‘~Ô&Ør-   rB   rC   rG   rJ   ©
rL   rM   rN   rO   rP   rQ   r!   r1   rA   rS   rT   s   @r,   rV   rV   U   s$   ø„ ñð €GØ'Ðö2ó
%÷r-   rV   c                  ó>   ‡ — e Zd ZdZdZdZddˆ fd„Zd	d„Zd
d„Zˆ xZ	S )ÚUpdatesTransformeruì  Capture 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)Úupdatesc                ób   •— t         ‰| �  |«       t        «       | _        t	        |«      | _        y rY   rZ   r(   s     €r,   r!   zUpdatesTransformer.__init__‰   ó%   ø€ Ü‰Ñ˜ÔÜ3@³?ˆŒ	Ü&*¨5£kˆÕr-   c                ó   — d| j                   iS )Nrb   r/   r0   s    r,   r1   zUpdatesTransformer.initŽ   s   € Ø˜4Ÿ9™9Ð%Ð%r-   c                ó‚   — |d   dk7  ry|d   }|d   | j                   k7  ry| j                  j                  |d   «       y)Nr7   rb   Tr8   r9   r:   r]   r^   s      r,   rA   zUpdatesTransformer.process‘   sG   € Ø�‰?˜iÒ'ØØ�x‘ˆØ�+Ñ $×"2Ñ"2Ò2ØØ�	‰	�‰�v˜f‘~Ô&Ør-   rB   rC   rG   rJ   r_   rT   s   @r,   ra   ra   x   s$   ø„ ñð €GØ(Ðö2ó
&÷r-   ra   c                  ó–   ‡ — e Zd ZdZdZdZddˆ fd„Zdd„Zdd„Zdd„Z		 	 	 	 	 	 	 	 dd„Z
dd	„Z	 	 	 	 	 	 	 	 dd
„Zdd„Zdd„Zdd„Zˆ xZS )ÚMessagesTransformeru>  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)Úmessagesc                óª   •— t         ‰| �  |«       t        «       | _        i | _        t        «       | _        d | _        d | _        t        |«      | _
        y rY   )r    r!   r   r"   Ú_by_runÚsetÚ_ignored_runsÚ_pump_fnÚ	_apump_fnr&   r'   r(   s     €r,   r!   zMessagesTransformer.__init__È   sH   ø€ Ü‰Ñ˜ÔÜ4A³OˆŒ	ð 46ˆŒÜ'*£uˆÔØ37ˆŒØ?CˆŒô '+¨5£kˆÕr-   c                ó   — d| j                   iS )Nri   r/   r0   s    r,   r1   zMessagesTransformer.initÕ   s   € Ø˜DŸI™IÐ&Ð&r-   c                ó   — || _         y)zIWire the sync pull callback. Called by GraphRunStream._wire_request_more.N)rn   ©r)   Úfns     r,   Ú
_bind_pumpzMessagesTransformer._bind_pumpØ   s	   € àˆ�r-   c                ó   — || _         y)zèWire 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)ro   rr   s     r,   Ú_bind_apumpzMessagesTransformer._bind_apumpÜ   s   € ð ˆ�r-   c               óú   — | j                   �+t        |||¬«      }|j                  | j                   «       |S | j                  �+t	        |||¬«      }|j                  | j                  «       |S t        |||¬«      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.
        ©r9   ÚnodeÚ
message_id)ro   r	   Úset_arequest_morern   r
   Úset_request_more)r)   r9   ry   rz   ÚastreamÚstreams         r,   Ú_make_streamz MessagesTransformer._make_streamå   s†   € ð �>‰>Ð%Ü*Ø#ØØ%ôˆGð
 ×%Ñ% d§n¡nÔ5ØˆNØ�=‰=Ð$Ü&5Ø#ØØ%ô'ˆFð
 ×#Ñ# D§M¡MÔ2ØˆMÜ#ØØØ!ô
ð 	
r-   c                ó¢  — |d   dk7  ry|d   }|d   | j                   k7  ry|d   \  }}|j                  d«      }|rt        |j                  dd	«      «      nd	}t        |t        «      r#d
|v r| j                  t        d|«      ||¬«       yt        |t        «      r3t        |t        «      s#t        |t        «      s| j                  ||¬«       y)Nr7   ri   Tr8   r9   r:   Úlanggraph_nodeÚrun_idÚ r@   r   )r‚   ry   )ry   )r'   r=   ÚstrÚ
isinstanceÚdictÚ_route_protocol_eventr   r   r   r   Ú_route_whole_message)r)   r@   r8   ÚpayloadÚmetadatary   r‚   s          r,   rA   zMessagesTransformer.process	  sÕ   € Ø�‰?˜jÒ(ØØ�x‘ˆØ�+Ñ $×"2Ñ"2Ò2Øà" 6™NÑˆ�Ø#Ÿ<™<Ð(8Ó9ˆÙ4<”�X—\‘\ (¨BÓ/Ô0À"ˆä�gœtÔ$¨°GÑ);Ø×&Ñ&Ü�^ WÓ-°fÀ4ð 'ô ð ô �w¤Ô,Ü˜w¬Ô7Ü˜w¬Ô4à×%Ñ% g°DÐ%Ô9ð
 r-   c               óP  — |j                  d«      }|dk(  rž|j                  d«      dk(  r| j                  j                  |«       y |j                  d«      }| j                  g ||�t	        |«      nd ¬«      }|| j
                  |<   | j                  j                  |«       |j                  |«       y || j                  v r"|dk(  r| j                  j                  |«       y y || j
                  v r4| j
                  |   }|j                  |«       |dk(  r| j
                  |= y y y )Nr@   zmessage-startÚroleÚtoolrz   rx   zmessage-finish)
r=   rm   Úaddr   r„   rk   r"   r?   ÚdispatchÚdiscard)r)   r@   r‚   ry   Ú
event_typerz   r~   s          r,   r‡   z)MessagesTransformer._route_protocol_event$  s  € ð —Y‘Y˜wÓ'ˆ
Ø˜Ò(ð �y‰y˜Ó  FÒ*Ø×"Ñ"×&Ñ& vÔ.ØØŸ™ <Ó0ˆJØ×&Ñ&ØØØ.8Ð.Dœ3˜zœ?È$ð 'ó ˆFð
 $*ˆD�L‰L˜Ñ Ø�I‰I�N‰N˜6Ô"Ø�O‰O˜EÕ"Ø�t×)Ñ)Ñ)ØÐ-Ò-Ø×"Ñ"×*Ñ*¨6Õ2ð .à�t—|‘|Ñ#Ø—\‘\ &Ñ)ˆFØ�O‰O˜EÔ"ØÐ-Ò-Ø—L‘L Ñ(ð .ð $r-   c               óÐ   — | j                  g ||j                  ¬«      }t        ||j                  ¬«      D ]  }|j                  |«       Œ | j                  j                  |«       y )Nrx   )rz   )r   Úidr   r�   r"   r?   )r)   Úmessagery   r~   Úevts        r,   rˆ   z(MessagesTransformer._route_whole_messageD  sO   € Ø×"Ñ"¨R°dÀwÇzÁzÐ"ÓRˆÜ$ W¸¿¹×DˆCØ�O‰O˜CÕ ð Eà�	‰	�‰�vÕr-   c                ól   — | j                   j                  «        | j                  j                  «        y)uJ   Clear any routing state â€” streams close themselves via `message-finish`.N)rk   Úclearrm   r0   s    r,   ÚfinalizezMessagesTransformer.finalizeJ  s$   € à�‰×ÑÔØ×Ñ× Ñ Õ"r-   c                óÞ   — t        | j                  j                  «       «      D ]  }|j                  |«       Œ | j                  j	                  «        | j
                  j	                  «        y)zCPropagate run error to any streams still open when the graph fails.N)r&   rk   r   Úfailr—   rm   )r)   Úerrr~   s      r,   rš   zMessagesTransformer.failO  sL   € ä˜4Ÿ<™<×.Ñ.Ó0Ö1ˆFØ�K‰K˜Õð 2à�‰×ÑÔØ×Ñ× Ñ Õ"r-   rB   rC   rG   )rs   zCallable[[], bool]rE   rF   )rs   zCallable[[], Awaitable[bool]]rE   rF   )r9   ú	list[str]ry   ú
str | Nonerz   r�   rE   r
   rJ   )r@   r   r‚   r„   ry   r�   rE   rF   )r”   r   ry   r�   rE   rF   ©rE   rF   ©r›   ÚBaseExceptionrE   rF   )rL   rM   rN   rO   rP   rQ   r!   r1   rt   rv   r   rA   r‡   rˆ   r˜   rš   rS   rT   s   @r,   rh   rh   ›   s˜   ø„ ñ'ðR €GØ)Ðö2ó'óóð"
ð ð"
ð ð	"
ð
 ð"
ð 
ó"
óHð6)àð)ð ð	)ð
 ð)ð 
ó)ó@ó#÷
#r-   rh   )ÚstartedÚ	completedÚfailedÚinterruptedÚdrainedc                ó>   — | j                  d«      \  }}}||r|fS dfS )zÁSplit 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)ÚsegmentÚnameÚsepÚtask_ids       r,   Ú_parse_ns_segmentr­   Z  s0   € ð !×*Ñ*¨3Ó/Ñ€Dˆ#ˆwØ™C�Ð)Ð) TÐ)Ð)r-   c                  óN   — e Zd ZU dZded<   ded<   ded<   ded<   d	ed
<   ded<   y)Ú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@   rœ   r9   zNotRequired[str]Ú
graph_nameÚtrigger_call_idzNotRequired[LifecycleCause]Úcauser5   N)rL   rM   rN   rO   Ú__annotations__r<   r-   r,   r¯   r¯   d  s-   … ñð ÓØÓØ Ó Ø%Ó%Ø&Ó&ØÔr-   r¯   F)Útotalc                  ó®   ‡ — e Zd ZdZdZddˆ fd„Zdd„Z	 	 	 	 	 	 	 	 dd„Z	 	 	 	 	 	 	 	 dd„Zdd„Z	dd„Z
dd	„Zdd
„Z	 	 	 	 	 	 dd„Zdd„Zdd„Zdd„Zˆ xZS )Ú_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.
    ©Útasksc                óz   •— t         ‰| �  |«       t        «       | _        i | _        i | _        i | _        d | _        y rY   )r    r!   rl   Ú_seenÚ_openÚ	_lc_by_nsÚ_pending_tool_callsÚ_pending_causer(   s     €r,   r!   z_TasksLifecycleBase.__init__”  s?   ø€ Ü‰Ñ˜ÔÜ+.«5ˆŒ
ð 24ˆŒ
ð =?ˆŒð 46ˆÔ ð
 6:ˆÕr-   c                ó   — t         ‚)uF   Scope filter â€” return True iff `ns` is in this transformer's region.©ÚNotImplementedError©r)   Únss     r,   Ú_should_trackz!_TasksLifecycleBase._should_track®  s   € ä!Ð!r-   c                ó   — t         ‚)z™Fired once per discovered namespace (first observed task event).

        The triggering `cause` (if any) is available as `self._pending_cause`.
        rÁ   )r)   rÄ   r±   r²   s       r,   Ú_on_startedz_TasksLifecycleBase._on_started²  s
   € ô "Ð!r-   c                ó   — t         ‚)z{Fired once per tracked namespace when its parent's result arrives,
        or via finalize/fail safety-net sweeps.
        rÁ   )r)   rÄ   Ústatusr5   s       r,   Ú_on_terminalz _TasksLifecycleBase._on_terminal¾  s
   € ô "Ð!r-   c                óà   — |d   dk7  ryt        |d   d   «      }|d   d   }d|v r| j                  ||«       y| j                  ||«       | j                  |«       | j	                  ||«       y)	Nr7   r¹   Tr8   r9   r:   ÚresultF)ÚtupleÚ_handle_task_resultÚ_record_identityÚ_record_pending_tool_callsÚ_handle_task_start)r)   r@   rÄ   r:   s       r,   rA   z_TasksLifecycleBase.processË  s„   € Ø�‰?˜gÒ%ØÜ�5˜‘? ;Ñ/Ó0ˆØ�X‰˜vÑ&ˆØ�tÑØ×$Ñ$ R¨Ô.ð ð ×!Ñ! " dÔ+Ø×+Ñ+¨DÔ1Ø×#Ñ# B¨Ô-ð r-   c                óˆ   — || j                   v ry|j                  d«      xs i }|j                  d«      | j                   |<   y)ay  Record 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)r½   r=   )r)   rÄ   r:   rŠ   s       r,   rÏ   z$_TasksLifecycleBase._record_identityÛ  s=   € ð �—‘ÑØØ—8‘8˜JÓ'Ò-¨2ˆØ%Ÿ\™\¨/Ó:ˆ�‰�rÒr-   c                óÚ  — |j                  d«      }t        |t        «      sy|j                  d«      }d}t        |t        «      rFt        |j                  d«      t        «      r'|d   j                  d«      }t        |t        «      rQ|}nNt        |t        «      r>|D ]9  }t        |t        «      sŒt        |j                  d«      t        «      sŒ4|d   } n |�|| j
                  |<   yy)a  Harvest 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:<task_id>` 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.
        r“   NÚinputÚ	tool_call)r=   r…   r„   r†   r&   r¾   )r)   r:   r¬   r‰   Útool_call_idÚ	candidateÚtcs          r,   rÐ   z._TasksLifecycleBase._record_pending_tool_callsè  sË   € ð —(‘(˜4“.ˆÜ˜'¤3Ô'ØØ—(‘(˜7Ó#ˆØ#'ˆô �gœtÔ$¬°G·K±KÀÓ4LÌdÔ)SØ Ñ,×0Ñ0°Ó6ˆIÜ˜)¤SÔ)Ø(‘ä˜¤Ô&Û�Ü˜b¤$Õ'¬J°r·v±v¸d³|ÄSÕ,IØ#% d¡8�LÙð ð Ð#Ø0<ˆD×$Ñ$ WÒ-ð $r-   c                ó¾  — | j                  |«      r|| j                  v ry | j                  j                  |«       t        |d   «      \  }}|j	                  d«      xs i }|j	                  d«      }|d u}|r|n|xs d }d }	|r-|�+| j
                  j	                  |«      }
|
rdt        |
«      dœ}	|	| _        | j                  |||«       |�|| j                  |<   y y )NéÿÿÿÿrŠ   rÓ   ÚtoolCall)Útyper×   )
rÅ   r»   rŽ   r­   r=   r¾   r„   r¿   rÇ   r¼   )r)   rÄ   r:   Úparsed_namer²   rŠ   Úchild_lcÚis_subagentr±   r³   r×   s              r,   rÑ   z&_TasksLifecycleBase._handle_task_start  så   € Ø×!Ñ! "Ô%¨¨t¯z©zÑ)9ØØ�
‰
�‰�rÔÜ'8¸¸B¹Ó'@Ñ$ˆ�_Ø—8‘8˜JÓ'Ò-¨2ˆØ—<‘< Ó0ˆð  dÐ*ˆÙ!,‘X°;Ò3FÀ$ˆ
Ø'+ˆÙ˜?Ð6Ø×3Ñ3×7Ñ7¸ÓHˆLÙØ!+¼SÀÓ=NÑO�ð $ˆÔØ×Ñ˜˜Z¨Ô9ØÐ&Ø,ˆD�J‰J�rŠNð 'r-   c                ó  — |j                  d«      }|sg S g }t        | j                  j                  «       «      D ]B  \  }}|dd |k7  s||k7  rŒt	        |«      \  }}|j                  |||f«       | j                  |= ŒD |S )z>Return and remove tracked children closed by this task result.r“   NrÛ   )r=   r&   r¼   ÚitemsÚ_terminal_from_resultÚappend)	r)   rÄ   r:   Ú	result_idÚtransitionsÚchild_nsÚparent_task_idrÉ   r5   s	            r,   Ú_pop_terminal_transitionsz-_TasksLifecycleBase._pop_terminal_transitions$  s�   € ð —H‘H˜T“Nˆ	ÙØˆIØPRˆÜ(,¨T¯Z©Z×-=Ñ-=Ó-?Ö(@Ñ$ˆH�nØ˜˜ˆ} Ò" n¸	Ò&AØÜ1°$Ó7‰MˆF�EØ×Ñ ¨&°%Ð8Ô9Ø—
‘
˜8Ñ$ð )Að Ðr-   c                ó`   — | j                  ||«      D ]  \  }}}| j                  |||«       Œ y rY   )ré   rÊ   )r)   rÄ   r:   rç   rÉ   r5   s         r,   rÎ   z'_TasksLifecycleBase._handle_task_result4  s3   € Ø'+×'EÑ'EÀbÈ$Ö'OÑ#ˆH�f˜eØ×Ñ˜h¨°Õ6ñ (Pr-   c                ó’   — t        | j                  «      D ]  }| j                  |dd«       Œ | j                  j                  «        y)zAEmit `completed` for any tracked namespace still open at run end.r¢   N)r&   r¼   rÊ   r—   rÃ   s     r,   r˜   z_TasksLifecycleBase.finalize8  s7   € ä�t—z‘zÖ"ˆBØ×Ñ˜b +¨tÕ4ð #à�
‰
×ÑÕr-   c                ó®   — t        |«      \  }}t        | j                  «      D ]  }| j                  |||«       Œ | j                  j	                  «        y)z:Emit terminal status for any tracked namespace still open.N)Ú_status_from_exceptionr&   r¼   rÊ   r—   )r)   r›   rÉ   Ú	error_strrÄ   s        r,   rš   z_TasksLifecycleBase.fail>  sF   € ä2°3Ó7Ñˆ�	Ü�t—z‘zÖ"ˆBØ×Ñ˜b &¨)Õ4ð #à�
‰
×ÑÕr-   rB   rC   ©rÄ   rD   rE   rK   ©rÄ   rD   r±   r�   r²   r�   rE   rF   ©rÄ   rD   rÉ   r°   r5   r�   rE   rF   rJ   )rÄ   rD   r:   rH   rE   rF   )r:   rH   rE   rF   )rÄ   rD   r:   rH   rE   z8list[tuple[tuple[str, ...], SubgraphStatus, str | None]]rž   rŸ   )rL   rM   rN   rO   rQ   r!   rÅ   rÇ   rÊ   rA   rÏ   rÐ   rÑ   ré   rÎ   r˜   rš   rS   rT   s   @r,   r·   r·   u  s°   ø„ ñð8 'Ðö:ó4"ð
"àð
"ð ð
"ð $ð	
"ð
 
ó
"ð	"àð	"ð ð	"ð ð		"ð
 
ó	"óó ;ó=ó<-ð<Ø!ðØ)7ðà	Aóó 7ó÷r-   r·   c                ó`   — t        | t        «      ryt        | t        «      rydt        | «      fS )zCMap a run exception to a subgraph terminal status and error string.)r¥   N©r¤   Nr£   )r…   r   r   r„   )r›   s    r,   rí   rí   F  s+   € ä�#”|Ô$ØÜ�#”~Ô&Ø"Ø”S˜“XÐÐr-   c                óh   — | j                  d«      ry| j                  d«      }|rdt        |«      fS y)züMap 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;   ró   r5   r£   )r¢   N)r=   r„   )r‰   r5   s     r,   rã   rã   O  s6   € ð ‡{�{�<Ô Ø"Ø�K‰K˜Ó €EÙØœ˜U›Ð#Ð#Ør-   c                  ój   ‡ — e Zd ZdZdZdd	ˆ fd„Zd
d„Zdd„Z	 	 	 	 	 	 	 	 dd„Z	 	 	 	 	 	 	 	 dd„Z	ˆ xZ
S )ÚLifecycleTransformeru®  Surface 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`.
    Tc                óD   •— t         ‰| �  |«       t        d«      | _        y ©NÚ	lifecycle)r    r!   r   Ú_channelr(   s     €r,   r!   zLifecycleTransformer.__init__s  s   ø€ Ü‰Ñ˜ÔÜ9FÀ{Ó9Sˆ�r-   c                ó   — d| j                   iS rø   )rú   r0   s    r,   r1   zLifecycleTransformer.initw  s   € Ø˜TŸ]™]Ð+Ð+r-   c                óp   — t        | j                  «      }t        |«      |kD  xr |d | | j                  k(  S rY   ©Úlenr*   ©r)   rÄ   Údepths      r,   rÅ   z"LifecycleTransformer._should_trackz  s1   € Ü�D—J‘J“ˆÜ�2‹w˜‰Ò; 2 f u :°·±Ñ#;Ð;r-   c                óš   — |€y dt        |«      dœ}|r||d<   ||d<   | j                  }|�||d<   | j                  j                  |«       y )Nr¡   ©r@   r9   r±   r²   r³   )r&   r¿   rú   r?   )r)   rÄ   r±   r²   r‰   r³   s         r,   rÇ   z LifecycleTransformer._on_started~  sb   € ð Ð"ð Ø.7ÄdÈ2ÃhÑ$OˆÙØ$.ˆG�LÑ!Ø%4ˆÐ!Ñ"Ø×#Ñ#ˆØÐØ$ˆG�GÑØ�‰×Ñ˜7Õ#r-   c                ód   — |t        |«      dœ}|�||d<   | j                  j                  |«       y )Nr  r5   )r&   rú   r?   )r)   rÄ   rÉ   r5   r‰   s        r,   rÊ   z!LifecycleTransformer._on_terminal’  s4   € ð /5Ä4ÈÃ8Ñ$LˆØÐØ$ˆG�GÑØ�‰×Ñ˜7Õ#r-   rB   rC   rG   rï   rð   rñ   )rL   rM   rN   rO   rP   r!   r1   rÅ   rÇ   rÊ   rS   rT   s   @r,   rö   rö   `  su   ø„ ñð  €GöTó,ó<ð$àð$ð ð$ð $ð	$ð
 
ó$ð(	$àð	$ð ð	$ð ð		$ð
 
÷	$r-   rö   c                  ó*  ‡ — e Zd ZdZdZdZddˆ fd„Zdd„Zdd„Zdd„Z		 	 	 	 	 	 	 	 dd„Z
	 	 	 	 	 	 	 	 dd„Z	 	 	 	 	 	 	 	 dd	„Z	 	 	 	 	 	 	 	 dd
„Z	 	 	 	 	 	 	 	 dd„Z	 	 	 	 	 	 	 	 dd„Z	 	 	 	 dd„Zd ˆ fd„Zd d„Zd!d„Zd!d„Zd"d„Zd"d„Zd#d„Zd#d„Zˆ xZS )$Ú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`.
    Tc                ó^   •— t         ‰| �  |«       t        «       | _        i | _        d | _        y rY   )r    r!   r   r"   Ú_handlesÚ_muxr(   s     €r,   r!   zSubgraphTransformer.__init__³  s1   ø€ Ü‰Ñ˜Ôä‹Oð 	Œ	ð
 ð 	Œð '+ˆ�	r-   c                ó   — d| j                   iS )NÚ	subgraphsr/   r0   s    r,   r1   zSubgraphTransformer.init½  s   € Ø˜TŸY™YÐ'Ð'r-   c                ó   — || _         y rY   )r  )r)   Úmuxs     r,   Ú_on_registerz SubgraphTransformer._on_registerÀ  s	   € Øˆ�	r-   c                óv   — t        | j                  «      }t        |«      |dz   k(  xr |d | | j                  k(  S )Né   rý   rÿ   s      r,   rÅ   z!SubgraphTransformer._should_trackÃ  s8   € ô �D—J‘J“ˆÜ�2‹w˜% !™)Ñ#Ò@¨¨6¨E¨
°d·j±jÑ(@Ð@r-   c                ó  — | j                   €y 	 | j                   j                  |«      }|j                  rt        nt
        } |||||¬«      }|| j                  |<   | j                  j                  |«       y # t        $ r Y y w xY w)N)r  Úpathr±   r²   )	r  Ú_make_childÚRuntimeErrorÚis_asyncr   r   r  r"   r?   )r)   rÄ   r±   r²   Ú	child_muxÚ
handle_clsÚhandles          r,   rÇ   zSubgraphTransformer._on_startedÉ  s‰   € ð �9‰9ÐØð	ØŸ	™	×-Ñ-¨bÓ1ˆIð 09×/AÒ/AÕ+ÔGXˆ
ñ ØØØ!Ø+ô	
ˆð #ˆ�‰�bÑØ�	‰	�‰�vÕøô ò 	Ùð	ús   �A9 Á9	BÂBc                óŒ   — | j                   j                  |«      }|�| j                  |||«      sy | j                  |||«       y rY   )r  r=   Ú_mark_terminalÚ_close_or_fail_handle©r)   rÄ   rÉ   r5   r  s        r,   rÊ   z SubgraphTransformer._on_terminalâ  sC   € ð —‘×"Ñ" 2Ó&ˆØˆ> ×!4Ñ!4°V¸VÀUÔ!KØØ×"Ñ" 6¨6°5Õ9r-   c              ƒ  ó¨   K  — | j                   j                  |«      }|�| j                  |||«      sy | j                  |||«      ƒ d {  –—†  y 7 Œ­wrY   )r  r=   r  Ú_aclose_or_fail_handler  s        r,   Ú_aon_terminalz!SubgraphTransformer._aon_terminalí  sM   è ø€ ð —‘×"Ñ" 2Ó&ˆØˆ> ×!4Ñ!4°V¸VÀUÔ!KØØ×)Ñ)¨&°&¸%Ó@×@Ò@ús   ‚AAÁ
AÁAc                ód   — |j                   ry||_        |�|j                  €||_        d|_         y)z>Mark a handle terminal once. Returns True on first transition.FT)Ú_seen_terminalrÉ   r5   ©r)   r  rÉ   r5   s       r,   r  z"SubgraphTransformer._mark_terminalø  s8   € ð × Ò ØØˆŒØÐ §¡Ð!5Ø ˆFŒLØ $ˆÔØr-   c                óî   — |j                   � |j                   j                  j                  ry |dk(  r)|j                   j                  t	        |xs d«      «       y |j                   j                  «        y ©Nr£   zSubgraph failed)r  Ú_eventsÚ_closedrš   r  Úcloser!  s       r,   r  z)SubgraphTransformer._close_or_fail_handle  sX   € ð �;‰;Ð &§+¡+×"5Ñ"5×"=Ò"=ØØ�XÒØ�K‰K×Ñœ\¨%Ò*DÐ3DÓEÕFà�K‰K×ÑÕr-   c              ƒ  ó  K  — |j                   � |j                   j                  j                  ry |dk(  r1|j                   j                  t	        |xs d«      «      ƒ d {  –—†  y |j                   j                  «       ƒ d {  –—†  y 7 Œ(7 Œ­wr#  )r  r$  r%  Úafailr  Úacloser!  s       r,   r  z*SubgraphTransformer._aclose_or_fail_handle  sr   è ø€ ð �;‰;Ð &§+¡+×"5Ñ"5×"=Ò"=ØØ�XÒØ—+‘+×#Ñ#¤L°Ò1KÐ:KÓ$LÓM×MÑMà—+‘+×$Ñ$Ó&×&Ñ&ð Nøà&ús$   ‚ABÁ B	Á!"BÂBÂBÂBc                ó  — t        |d   d   «      }t        | j                  «      }t        |«      |dz   k  ry | j                  j	                  |d |dz    «      }|�,|j
                  � |j
                  j                  j                  ry |S )Nr8   r9   r  )rÍ   rþ   r*   r  r=   r  r$  r%  )r)   r@   rÄ   r   r  s        r,   Ú_handle_for_eventz%SubgraphTransformer._handle_for_event!  s}   € ô �5˜‘? ;Ñ/Ó0ˆÜ�D—J‘J“ˆÜˆr‹7�U˜Q‘YÒØØ—‘×"Ñ" 2 k¨°©	 ?Ó3ˆØˆ>˜VŸ[™[Ð0°F·K±K×4GÑ4G×4OÒ4OØØˆr-   c                ó¤   •— t         ‰| �  |«      }| j                  |«      }|�,|j                  |«       |j                  j                  |«       |S rY   )r    rA   r+  Ú_observe_eventr  r?   )r)   r@   Úkeepr  r+   s       €r,   rA   zSubgraphTransformer.process-  sN   ø€ ô ‰w‰˜uÓ%ˆØ×'Ñ'¨Ó.ˆØÐØ×!Ñ! %Ô(Ø�K‰K×Ñ˜UÔ#Øˆr-   c              ƒ  óÐ  K  — |d   dk(  rŒt        |d   d   «      }|d   d   }d|v r7| j                  ||«      D ]!  \  }}}| j                  |||«      ƒ d {  –—†  Œ# n5| j                  ||«       | j	                  |«       | j                  ||«       d}nd}| j                  |«      }|�4|j                  |«       |j                  j                  |«      ƒ d {  –—†  |S 7 ŒŠ7 Œ­w)	Nr7   r¹   r8   r9   r:   rÌ   FT)
rÍ   ré   r  rÏ   rÐ   rÑ   r+  r-  r  Úapush)	r)   r@   rÄ   r:   rç   rÉ   r5   r.  r  s	            r,   ÚaprocesszSubgraphTransformer.aprocess7  sü   è ø€ ð �‰?˜gÒ%Ü�u˜X‘ {Ñ3Ó4ˆBØ˜‘? 6Ñ*ˆDØ˜4ÑØ/3×/MÑ/MÈbÐRVÖ/WÑ+�H˜f eØ×,Ñ,¨X°v¸uÓE×EÑEñ 0Xð ×%Ñ% b¨$Ô/Ø×/Ñ/°Ô5Ø×'Ñ'¨¨DÔ1Ø‰DàˆDØ×'Ñ'¨Ó.ˆØÐØ×!Ñ! %Ô(Ø—+‘+×#Ñ# EÓ*×*Ð*Øˆð Føð +ús%   ‚AC&ÁC"ÁBC&ÃC$ÃC&Ã$C&c                ó�  — d }t        | j                  «      D ]  }	 | j                  |dd «       Œ | j                  j	                  «        | j
                  j                  «       D ]*  }| j                  |dd «      sŒ	 | j                  |dd «       Œ, |S # t        $ r}|€|}Y d }~ŒŽd }~ww xY w# t        $ r}|€|}Y d }~Œ[d }~ww xY w©Nr¢   )	r&   r¼   rÊ   r    r—   r  r   r  r  ©r)   Úfirst_errorrÄ   Úer  s        r,   Ú_complete_open_handlesz*SubgraphTransformer._complete_open_handlesP  sÆ   € Ø,0ˆÜ�t—z‘zÖ"ˆBð$Ø×!Ñ! " k°4Õ8ð #ð 	�
‰
×ÑÔØ—m‘m×*Ñ*Ö,ˆFØ×"Ñ" 6¨;¸Õ=ð(Ø×.Ñ.¨v°{ÀDÕIð -ð Ðøô !ò $ØÐ&Ø"#�Kÿøð$ûô %ò (Ø"Ð*Ø&'˜ÿøð(ús/   œBÁ=B.Â	B+ÂB&Â&B+Â.	CÂ7C Ã Cc              ƒ  óÀ  K  — d }t        | j                  «      D ]  }	 | j                  |dd «      ƒ d {  –—†  Œ  | j                  j	                  «        | j
                  j                  «       D ]2  }| j                  |dd «      sŒ	 | j                  |dd «      ƒ d {  –—†  Œ4 |S 7 Œq# t        $ r}|€|}Y d }~Œ d }~ww xY w7 Œ$# t        $ r}|€|}Y d }~Œgd }~ww xY w­wr3  )	r&   r¼   r  r    r—   r  r   r  r  r4  s        r,   Ú_acomplete_open_handlesz+SubgraphTransformer._acomplete_open_handlesb  sÞ   è ø€ Ø,0ˆÜ�t—z‘zÖ"ˆBð$Ø×(Ñ(¨¨[¸$Ó?×?Ñ?ð #ð 	�
‰
×ÑÔØ—m‘m×*Ñ*Ö,ˆFØ×"Ñ" 6¨;¸Õ=ð(Ø×5Ñ5°f¸kÈ4ÓP×PÑPð -ð Ðð @ùÜ ò $ØÐ&Ø"#�Kÿøð$úð QùÜ$ò (Ø"Ð*Ø&'˜ÿøð(üsz   ‚CžB(´B&µB(¹ACÂCÂCÂCÂ"CÂ&B(Â(	B?Â1B:Â5CÂ:B?Â?CÃCÃ	CÃCÃCÃCÃCc                ó,   — | j                  «       }|�|‚y rY   )r7  ©r)   r5  s     r,   r˜   zSubgraphTransformer.finalizet  s!   € Ø×1Ñ1Ó3ˆØÐ"ØÐð #r-   c              ƒ  óH   K  — | j                  «       ƒ d {  –—† }|�|‚y 7 Œ	­wrY   )r9  r;  s     r,   Ú	afinalizezSubgraphTransformer.afinalizey  s-   è ø€ Ø ×8Ñ8Ó:×:ˆØÐ"ØÐð #ð ;ús   ‚"– —
"c                ó®  — t        |«      \  }}| j                  j                  «        | j                  j	                  «       D ]_  }| j                  |||«       |j                  €Œ#|j                  j                  j                  rŒD	 |j                  j                  |«       Œa y # t        $ r% t        j                  d|j                  d¬«       Y Œ�w xY w©NzRError failing subgraph mini-mux at %s; subscribers may not see the terminal error.T)Úexc_info)rí   r¼   r—   r  r   r  r  r$  r%  rš   Ú	ExceptionÚ_loggerÚwarningr  ©r)   r›   rÉ   rî   r  s        r,   rš   zSubgraphTransformer.fail~  s¯   € Ü2°3Ó7Ñˆ�	Ø�
‰
×ÑÔØ—m‘m×*Ñ*Ö,ˆFØ×Ñ ¨°	Ô:Ø�{‰{Ñ&¨v¯{©{×/BÑ/B×/JÓ/JðØ—K‘K×$Ñ$ SÕ)ñ	 -øô
 !ò Ü—O‘OðFàŸ™Ø!%ð	 $ö ðús   ÂB&Â&+CÃCc              ƒ  óÊ  K  — t        |«      \  }}| j                  j                  «        | j                  j	                  «       D ]g  }| j                  |||«       |j                  €Œ#|j                  j                  j                  rŒD	 |j                  j                  |«      ƒ d {  –—†  Œi y 7 Œ# t        $ r% t        j                  d|j                  d¬«       Y Œšw xY w­wr?  )rí   r¼   r—   r  r   r  r  r$  r%  r(  rA  rB  rC  r  rD  s        r,   r(  zSubgraphTransformer.afailŽ  s»   è ø€ Ü2°3Ó7Ñˆ�	Ø�
‰
×ÑÔØ—m‘m×*Ñ*Ö,ˆFØ×Ñ ¨°	Ô:Ø�{‰{Ñ&¨v¯{©{×/BÑ/B×/JÓ/JðØ Ÿ+™+×+Ñ+¨CÓ0×0Ñ0ñ	 -ð 1ùÜ ò Ü—O‘OðFàŸ™Ø!%ð	 $ö ðüsB   ‚A%C#Á( C#Â
B2Â(B0Â)B2Â-C#Â0B2Â2+C ÃC#ÃC Ã C#rB   rC   rG   )r  r   rE   rF   rï   rð   rñ   )r  ú*SubgraphRunStream | AsyncSubgraphRunStreamrÉ   r°   r5   r�   rE   rK   )r  rF  rÉ   r°   r5   r�   rE   rF   )r@   r   rE   z1SubgraphRunStream | AsyncSubgraphRunStream | NonerJ   rI   rž   rŸ   )rL   rM   rN   rO   rP   Úsupports_syncr!   r1   r  rÅ   rÇ   rÊ   r  r  r  r  r+  rA   r1  r7  r9  r˜   r=  rš   r(  rS   rT   s   @r,   r  r  ž  sm  ø„ ñð" €GØ€Mö+ó(óóAðàðð ðð $ð	ð
 
óð2	:àð	:ð ð	:ð ð		:ð
 
ó	:ð	Aàð	Að ð	Að ð		Að
 
ó	Aðà:ðð ðð ð	ð
 
óð à:ð ð ð ð ð	 ð
 
ó ð'à:ð'ð ð'ð ð	'ð
 
ó'ð
Ø"ð
à	:ó
õóó2ó$ó$ó
ó
÷ r-   r  c                  ó>   ‡ — e Zd ZdZdZdZddˆ fd„Zd	d„Zd
d„Zˆ xZ	S )ÚCheckpointsTransformeru‰  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)Úcheckpointsc                ób   •— t         ‰| �  |«       t        «       | _        t	        |«      | _        y rY   rZ   r(   s     €r,   r!   zCheckpointsTransformer.__init__´  rd   r-   c                ó   — d| j                   iS )NrJ  r/   r0   s    r,   r1   zCheckpointsTransformer.init¹  s   € Ø˜tŸy™yÐ)Ð)r-   c                ó‚   — |d   dk7  ry|d   }|d   | j                   k7  ry| j                  j                  |d   «       y)Nr7   rJ  Tr8   r9   r:   r]   r^   s      r,   rA   zCheckpointsTransformer.process¼  sG   € Ø�‰?˜mÒ+ØØ�x‘ˆØ�+Ñ $×"2Ñ"2Ò2ØØ�	‰	�‰�v˜f‘~Ô&Ør-   rB   rC   rG   rJ   r_   rT   s   @r,   rI  rI  Ÿ  s$   ø„ ñð" €GØ,Ðö2ó
*÷r-   rI  c                  ó>   ‡ — e Zd ZdZdZdZddˆ fd„Zd	d„Zd
d„Zˆ xZ	S )ÚDebugTransformeru  Capture 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)Údebugc                ób   •— t         ‰| �  |«       t        «       | _        t	        |«      | _        y rY   rZ   r(   s     €r,   r!   zDebugTransformer.__init__Ø  rd   r-   c                ó   — d| j                   iS )NrP  r/   r0   s    r,   r1   zDebugTransformer.initÝ  ó   € Ø˜Ÿ™Ð#Ð#r-   c                ó‚   — |d   dk7  ry|d   }|d   | j                   k7  ry| j                  j                  |d   «       y)Nr7   rP  Tr8   r9   r:   r]   r^   s      r,   rA   zDebugTransformer.processà  óG   € Ø�‰?˜gÒ%ØØ�x‘ˆØ�+Ñ $×"2Ñ"2Ò2ØØ�	‰	�‰�v˜f‘~Ô&Ør-   rB   rC   rG   rJ   r_   rT   s   @r,   rO  rO  Æ  s$   ø„ ñð €GØ&Ðö2ó
$÷r-   rO  c                  ó>   ‡ — e Zd ZdZdZdZddˆ fd„Zd	d„Zd
d„Zˆ xZ	S )ÚTasksTransformeru›  Capture 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.
    Tr¸   c                ób   •— t         ‰| �  |«       t        «       | _        t	        |«      | _        y rY   rZ   r(   s     €r,   r!   zTasksTransformer.__init__   rd   r-   c                ó   — d| j                   iS )Nr¹   r/   r0   s    r,   r1   zTasksTransformer.init  rS  r-   c                ó‚   — |d   dk7  ry|d   }|d   | j                   k7  ry| j                  j                  |d   «       y)Nr7   r¹   Tr8   r9   r:   r]   r^   s      r,   rA   zTasksTransformer.process  rU  r-   rB   rC   rG   rJ   r_   rT   s   @r,   rW  rW  ê  s$   ø„ ñð$ €GØ&Ðö2ó
$÷r-   rW  )r©   r„   rE   ztuple[str, str | None])r›   r    rE   ú!tuple[SubgraphStatus, str | None])r‰   rH   rE   r[  )9Ú
__future__r   ÚloggingÚtypingr   r   r   r   Ú-langchain_core.language_models._compat_bridger   Ú0langchain_core.language_models.chat_model_streamr	   r
   Úlangchain_core.messagesr   r   r   Úlangchain_protocol.protocolr   r   Útyping_extensionsr   r   Úlanggraph.errorsr   r   Úlanggraph.stream._typesr   r   Úlanggraph.stream.run_streamr   r   Úlanggraph.stream.stream_channelr   Úcollections.abcr   r   Úlanggraph.stream._muxr   Ú	getLoggerrL   rB  r   rV   ra   rh   r°   r­   r¯   r·   rí   rã   rö   r  rI  rO  rW  r<   r-   r,   Ú<module>rk     s  ðÝ "ã ß 4Ó 4å K÷÷ MÑ Lß Dß 4ç 9ß Dß QÝ 9áß3å/à
ˆ'×
Ñ
˜HÓ
%€ô6Ð)ô 6ôr Ð)ô  ôF Ð*ô  ôFy#Ð+ô y#ðx ÐSÑT€ó*ô�y¨õ ô"NÐ+ô NóbðØðà&óô";$Ð.ô ;$ô|~Ð-ô ~ôB$Ð.ô $ôN!Ð(ô !ôH%Ð(õ %r-   