"j=%SSKJr SSKrSSKrSSKrSSKrSSKJrJ r J r J r J r J r SSKJr SSKJr SSKJr SSKJr SSKJrJrJrJr SS KJrJr SS KJrJr SS K J!r! S S K"J#r#J$r% S SK&J'r'J(r(J)r) S SK*J+r+ S SK,J-r- \ S\.\S4\/\0\4/\ \4r1\(a@S SK2J3r3 S SK4J5r5 S SK6J7r7 S SK8J9r9 S SK:J;r; S SKr> S SK?J@r@ S SKAJBrB S SKCJDrD S SKEJFrFJGrG \"S\HSS9rI\"S \HSS!9rJ\"S"\%RS#9rL\"S$\%RS#9rN"S%S&\O\%R5rQS8S'jrRS9S(jrS\R"SS)9"S*S+55rU\R"S,SS-9"S.S/\\J55rV\VRrX\"\X5SS0.S:S1jj5rY\Y\VlW\"S2SS39rZS4\[S5'S;S6jr\\S[TU]U5 /UlgN)super__init__r7)selfiterable __class__s U/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/_run_context.pyr;EventStreamBuffer.__init__=s ",. cj>[TU]U5 URHnUR5 M gr9)r:appendr7set)r<eventwaiterr>s r?rCEventStreamBuffer.appendAs& ullF JJL#rA))r=z$Sequence[_messages.AgentStreamEvent]rE_messages.AgentStreamEventreturnNone) __name__ __module__ __qualname____firstlineno____doc__ __slots__r;rC__static_attributes__ __classcell__)r>s@r?r5r54s# I//rAr5c# [U[R5(aURS:wag[R "5nUR R[U5/5RU5 URnUb-URU5(aURXS9IShvN UR5 gN!UR5 f=f7f)zYDispatch an immediately dispatched capability event and mark it for stream deduplication. immediateNrE) isinstance _messagesCapabilityEventevent_dispatchasyncioEvent_pending_immediate_dispatches setdefaultidrCroot_capability listens_toon_eventrD)ctxrEsettled capabilitys r?dispatch_event_immediatergGs eY66 7 75;O;OS^;^mmoG%%00EB?FFwO((  !j&;&;E&B&B%%c%7 7 7  8  s0A:C!=7C 4C 5C 9C! C CC!c# URnUShvN n[U5nURRU5=n(a>UR S5nU(d URU UR 5IShvN O0Ub-UR U5(aURXS9IShvN URR XC57v MNNWN( g7f)zXDispatch events at their stream positions and deduplicate immediately dispatched events.NrrW) rar`r^getpopwaitrbrc_event_stream_replacements)rdstreamrfrEevent_idpendingres r?dispatch_event_streamrp]s$$J Bee977;;HE E7 Ekk!nG55h?,,.  # (=(=e(D(D%%c%7 7 7,,00AA B ! 7sJCCCCA&C?C0C0C1$CCCCC)frozencL\rSrSr%Sr\"5rS\S'\"5rS\S'Sr g)AnchoredEvidencenu!Reveal and load evidence the provider that served a response could still see. `RunContext.discovered_tool_names` and `loaded_capability_ids` are cut at any `CompactionPart`, because the consumer that matters for them is the *next* request, whose provider isn't knowable when history is parsed. A call the model already made is a different question with a different answer: the response records which provider served it, so a boundary that provider would have skipped on the wire — another provider's, or one whose payload it doesn't render — hid nothing from it. This holds what those parts of history still evidence. Additive, never a replacement: the sets it widens are shared mutable run state that tool execution writes in-step reveals into, so the widened view has to be a separate object. zfrozenset[str]discovered_tool_namesloaded_capability_idsrHN) rMrNrOrPrQ frozensetru__annotations__rvrSrHrAr?rsrsns) -6K>7`,5K>7\rArsF)reprkw_onlyc\rSrSr%SrS\S'S\S'S\S'\"S S S 9rS \S 'S rS\S'\"S S S 9r S\S'S r S\S'\"\ \ RS9rS\S'S rS\S'\"\S9rS\S'S rS\S'\rS\S'\"\\\4S9rS\S 'S rS \S!'S rS \S"'S#rS\S$'S#rS\S%'S#rS\S&'S rS\S''S rS\S('S r S\S)'S r!S \S*'S r"S \S+'S r#S,\S-'S r$S.\S/'\"S S S 9r%S0\S1'\"S S S 9r&S2\S3'\"S S S 9r'S4\S5'\"\\\ \(RR4S S69r*S7\S8'\"\\\ RV4S S69r,S9\S:'\"S S S 9r-S;\S<'\"S S S 9r.S=\S>'\"S S S 9r/S?\S@'\"SAS S69r0SB\SC'S r1SD\SE'\"S S S 9r2SF\SG'S r3SH\SI'\"SJS9r4SK\SL'\"\5\S9r6SM\SN'S r7SO\SP'\"\5\S9r8SM\SQ'\"SRS S69r9SS\ST'\"S S S 9r:SH\SU'\;SoSVj5r<\;\="SW\>SX9SpSYj55r?\?R\="SW\>SX9SqSZj55r?\;SrS[j5rA\;SrS\j5rB\;SsS]j5rCStS^jrD\;SuS_j5rE\;SuS`j5rF\;\="Sa\>SX9SuSbj55rG\;SuScj5rH\;SuSdj5rISvSejrJ\;SwSfj5rK\LSxSgj5rM\LSyShj5rMSzSijrMSjSk.S{SljjrNS|SmjrO\PRrRSnrSg )} RunContextz#Information about the current call.r/depsr$modelr*usageNF)r-ry str | None _model_idzUsageLimits | None usage_limitsz'Agent[RunContextAgentDepsT, Any] | Noneagentz,str | Sequence[_messages.UserContent] | Noneprompt)default_factoryzlist[_messages.ModelMessage]rrvalidation_contextrtracerbooltrace_include_contentintinstrumentation_versionzdict[str, int]retries tool_call_id tool_namerretry max_retriesrun_steptool_call_approvedtool_call_metadatapartial_outputrun_idconversation_idzdict[str, Any] | Nonemetadataz,ModelSettings | RealtimeModelSettings | Nonemodel_settingszlist[PendingMessage] | Nonepending_messageszRunCancellation | None _cancellationz'list[_messages.AgentStreamEvent] | None_event_stream_buffer)rryzdict[int, list[asyncio.Event]]r^z%dict[int, _messages.AgentStreamEvent]rlz7dict[tuple[str, str], _DurableOperationDispatch] | None_durable_operationsz)dict[str, AbstractCapability[Any]] | None_run_capabilities_by_idz%dict[str, RunHeldToolset[Any]] | None_run_held_toolsetsc0$r9rHrHrAr?RunContext.s_arAz$dict[str, dict[str, ToolDefinition]]_mcp_tool_defs_cachez(ToolManager[RunContextAgentDepsT] | None tool_managerzRealtimeSession | Nonerealtime_sessionz/AbstractCapability[RunContextAgentDepsT] | Nonerac0$r9rHrHrAr?rrNsfhrAz3dict[str, AbstractCapability[RunContextAgentDepsT]] capabilitiesset[str]rv bool | Nonecapability_activeruc[5$r9)rsrHrAr?rrsIYI[rArs_anchored_evidence _capabilitycUR$)zThe identifier from which the run's active `model` was resolved. This is `None` when the model was passed as an instance instead of being resolved from an identifier. The property is read-only; Pydantic AI manages the selection token internally. )rr<s r?model_idRunContext.model_ids~~rA`capability_loaded` is deprecated, use `capability_active` instead: the value is `True` for an always-on capability that was never loaded.)categorycUR$)u Whether the capability whose hook or callback is currently running is active right now. Deprecated: use [`capability_active`][pydantic_ai.tools.RunContext.capability_active]. This never meant "loaded" — it is `True` for an always-on capability nothing ever loaded. rrs r?capability_loadedRunContext.capability_loadeds%%%rAcXlgr9r)r<values r?rrs "'rAc[RRS5nUSL=(a [URUR 5$)uWhether this run is a realtime session, i.e. `model` is the connected `RealtimeModel`. Reliable from `before_run` through session close, including instruction resolution — unlike [`realtime_session`][pydantic_ai.tools.RunContext.realtime_session], which is only set once the session is connected. The class is looked up through `sys.modules` rather than imported: if the realtime package was never imported, no realtime model can exist, and a classic run should not pay for (or cycle into) that import. zpydantic_ai.realtimeN)sysmodulesrirXr RealtimeModel)r<realtimes r?rRunContext.realtimes8;;??#9:t#V 4::x?U?U(VVrAc4URUR:H$)zPWhether this is the last attempt at running this tool before an error is raised.)rrrs r? last_attemptRunContext.last_attemptszzT----rAc0URURp!URnUbUS::ag[ U5HIn[ U[ R5(dM$URRnU(aXS- s $Ss $ g![a gf=f)uFraction of the model's context window occupied as of the most recent model response. Computed as the latest response's reported [`total_tokens`][pydantic_ai.usage.RequestUsage.total_tokens] (input, including cached tokens, plus output) over the active model's [`context_window`][pydantic_ai.models.AbstractModel.context_window]. This estimates how full the next request may be; history processing and newly added content can change its actual size, and the value can exceed `1.0` when the last response came from a model with a larger window. Useful to trigger history compaction, e.g. in a [history processor](https://pydantic.dev/docs/ai/message-history#processing-message-history). Returns `None` — never a misleading `0.0` — when the ratio cannot be calculated: when the context window, usage, or message history is unavailable, or before the first model response. A [`FallbackModel`][pydantic_ai.models.fallback.FallbackModel] measures against the smallest of its candidates' windows. Nr) rrrcontext_windowreversedrXrY ModelResponser total_tokens)r<rrrmessagetokenss r?context_window_usedRunContext.context_window_useds$ "jj$--8--  !^q%8)G'9#:#:;; 3328v.BdB*  sB BBcbURcS5eURRU5 g)uAppend an event to the run's event buffer for the agent graph to drain into the event stream. Private framework plumbing — not public API. Only valid during an agent run, where the buffer is set (`_event_stream_buffer is not None`). Nz?events are only emitted during an agent run, which has a buffer)rrCr<rEs r? _emit_eventRunContext._emit_events0 ((4w6ww4 !!((/rAcURR5VVs1sHupURSLdMUiM snnUR-$s snnf)uPIDs of the capabilities whose contributions are live to the model right now. *Active*, deliberately not *available*: a capability is not something the model calls, so "available" would read as "offered in the catalog, there for the loading" — which is the opposite set, the deferred ones that are **not** yet contributing. Active means the capability's instructions, tools, settings and hooks are in force on this step: non-deferred capabilities (`defer_loading` not `True`) plus the deferred ones the model has loaded, so `active_capability_ids - loaded_capability_ids` is the auto/always-on subset. Tools keep the word *available* because for them there is only one question — may the model call this now? — and no catalog sense to collide with. So `is_tool_available` reads "revealed, and its owning capability is active". Two axes, deliberately not mixed. *Configuration* is set once by the author: a capability is either **deferred** (`defer_loading=True`) or **always-on**. *Runtime* is derived per step: **loaded** records what the model asked for, **active** what is in force. So "always-on" is the antonym of "deferred", never of "active" — an always-on capability is always active, and a deferred one becomes active once loaded. Distinct from `capabilities`, the full registry (including deferred ones not yet loaded). See `loaded_capability_ids` for the subset the model explicitly loaded. Reliable from `before_run` onwards: the `capabilities` registry is seeded once at run start, and `loaded_capability_ids` is refreshed from history before each model request, so the loaded subset grows across steps as the model loads capabilities. Because it grows step by step, where you read it in the [hook order](../hooks.md#hook-ordering) determines what you see — e.g. a capability loaded during one step is not reflected until the next step's hooks. T)ritems defer_loadingrvr<r`caps r?active_capability_ids RunContext.active_capability_idssT@#//557 7723;L;LTX;XB7  & &' ' s AAcbURURRUR--$)u`active_capability_ids`, widened by the anchored evidence for the response being dispatched. The single answer to "may this capability act on the call being dispatched right now?", and it has to be single: `is_tool_available` authorizes the call from it, and the `prepare_tools` dispatch gate decides from it whether the owning capability's filter runs over that tool. If only the first consulted the evidence, a tool authorized through a load the conservative window dropped would execute with its owner's `prepare_tools` never having run — the capability is not active, so nothing dispatched to it. The evidence is narrowed to the run's configured deferred ids — the shape every load record has, since only a deferred capability can be loaded. Inert for both predicates above, which look up an id that came from a registered capability either way; it is there so that a history naming a capability this run no longer configures doesn't leave a permanent difference in `ToolManager.resolved_capability_ids` and rebuild the tools every dispatch. `_deferred_capability_ids` rather than `capabilities` deliberately: it crosses the Temporal activity boundary, where reading the live registry raises. Outside tool-call dispatch `_anchored_evidence` is empty, so this is exactly `active_capability_ids`. )rrrv_deferred_capability_idsrs r?_dispatch_active_capability_ids*RunContext._dispatch_active_capability_ids s1,))  # # 9 9Dso    $(9(9(?(?(Gs8: : :: :+/::+;+;+=b+=AWAWX`Aa+=bbbs !B B cb[U[5(aRURbURRcXR;$URR U5nUcgOUnSSKJn URUR:waUR(dgURnURnUb9X@R;a*X@RUR-;aX@R;$UR UR"UR"-;agUSL=(d X@R;$)aWhether a function tool is currently available to the model. Pass a [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] when checking a definition held by a toolset, especially inside `get_tools`. This form evaluates the definition's own fields against the reveal state recorded in history, so it remains reliable when a wrapping toolset has removed the definition from the resolved tool set. Pass a tool name where [`tools`][pydantic_ai.tools.RunContext.tools] is reliable, such as model-request hooks or ordinary tool execution. The name form looks up the current definition in `tools`; when live tool state is unavailable (including inside a Temporal activity), it falls back to `available_tool_names`. An unknown name returns `False`. See [`available_tool_names`][pydantic_ai.tools.RunContext.available_tool_names] for the timing caveat, and [`ModelRequestParameters.revealed_tool_names`][pydantic_ai.models.ModelRequestParameters.revealed_tool_names] for the reveal state sent through the model-request pipeline. NFr)ToolSearchToolT)rXrrrrrinative_tools._tool_searchr with_nativekindr capability_idrrrvrrru)r<toolrrrevidences r?rRunContext.is_tool_availablePs dC   (D,=,=,C,C,K8888zz~~d+H H >   >#6#6 6x?U?U .. **  %!>!>>!;!;h>\>\!\\ $H$HH H == : :X=[=[ [ [ $] 9]9](]]rAcURbURRc0$URRR5VVs0sHupXR_M snn$s snnf)zAll tool definitions present this turn, keyed by name (includes still-deferred ones). Index `available_tool_names` into this for the callable subset.)rrrr)r<rrs r?rRunContext.toolss^    $(9(9(?(?(GI6:6G6G6M6M6S6S6UV6U mm#6UVVVsA*c # g7fr9rHrs r?emitRunContext.emitsBEc # g7fr9rHrs r?rrsJMrc^# URc [S5eSnURmTb9[U4SjURR 55TR 5nOURbURbrURRb[URRRUR5=nb)URRnX@R;aUOSn[U[R5(a"Uc [S5eURcX!l OITbTO#URRU=(d S5=nbUR (d [S5eUR"c/UR"b"UR"UlURUlUR%U5 ['X5IShvN U$N7f)u Emit a custom or capability event into the current run's event stream. Application code emits an instance of an application-defined [`CustomEvent` subclass](../agent.md#custom-events) with typed payload fields. Capability hooks and capability-contributed tools instead emit a typed [`CapabilityEvent`][pydantic_ai.messages.CapabilityEvent]. This method must be awaited, so it's available from async tools, capability hooks, history processors, and async output validators. Sync tools cannot emit events; write async tools instead. It's async rather than sync like [`enqueue`][pydantic_ai.tools.RunContext.enqueue] because immediate dispatch (below) awaits listeners before returning, and because widening a sync signature to async later would break every caller. The event reaches the run's `event_stream_handler`, [`Agent.run_stream_events`][pydantic_ai.agent.AbstractAgent.run_stream_events], [`Agent.iter`][pydantic_ai.agent.AbstractAgent.iter] streaming, and the UI adapters. When emitted from within a tool call and the event doesn't already set a [`tool_call_id`][pydantic_ai.messages.CustomEvent.tool_call_id], the current [`tool_call_id`][pydantic_ai.tools.RunContext.tool_call_id] and [`tool_name`][pydantic_ai.tools.RunContext.tool_name] are stamped on the event in place so consumers can attribute it to the originating tool call. By default, capability and application listeners run when the event's stream position is consumed, and this method returns without awaiting them. For tool-execution emissions this happens before the next model request. An event emitted during `before_model_request` may reach listeners only after that request begins, with the same as-soon-as-possible timing as [`RunContext.enqueue`][pydantic_ai.tools.RunContext.enqueue]. That is a statement about *when* listeners run, not about order: every consumer sees events in emission order either way. A [`CapabilityEvent`][pydantic_ai.messages.CapabilityEvent] class declared with `dispatch='immediate'` changes one thing — listeners are awaited before this method returns, so the emitter can read decision fields they set (this is what makes a cancelable event possible). Everything else is the same: the event still takes the stream position it would have taken, the same listeners run in the same order, and it is delivered exactly once. What stream consumers gain is that they never observe such an event mid-decision — the stream waits for its listeners to settle before yielding it, so the values they read are final. Args: event: The [`CustomEvent`][pydantic_ai.messages.CustomEvent] or [`CapabilityEvent`][pydantic_ai.messages.CapabilityEvent] to emit. Returns: The same event instance, with any attribution fields stamped. For an immediately dispatched decision event, both the return value and the passed reference reflect listener decisions. Raises: UserError: If this `RunContext` isn't backed by a running agent's event stream, or the event family doesn't belong to the current emitter. Nz`emit` is only available during an agent run (from tools, capability hooks, or `AgentRun.emit`). This `RunContext` has no event stream to emit into.c3:># UHupUTLdM Uv M g7fr9rH).0rrrfs r? "RunContext.emit..sZ+DKFzHY+Ds  zCapability events belong to capabilities and can only be emitted from a capability hook or capability-contributed tool. Application code should emit a `CustomEvent`; it can re-emit a received capability event as one.zgCapabilities should define and emit `CapabilityEvent` subclasses instead of application `CustomEvent`s.)rrrnextrrr`rrrrirrrXrYrZ_emits_app_eventsrrrg)r<rErrtool_capability_idownerrfs @r?rrsh  $ $ ,X %) %%  ! Z4+<+<+B+B+DZ\f\i\iM^^ 'D,=,=,IdN_N_NeNeNq))//33DNNCCP&*]]%@%@"6HL]L]6] 2cg eY66 7 7$8 ""*&3#$.#9Zt?P?P?T?TUbUhfh?i iE#55"     %$*;*;*G!%!2!2E "nnEO  't333  4sGG GG asap)prioritycURc [S5e[R"USU06nUcgURR U5 UR $)uuEnqueue content to be injected into the conversation. Safe to call directly from async tools, sync tools running in another thread, and capability hooks. Args: *content: One or more [`EnqueueContent`][pydantic_ai.run.EnqueueContent] items. Adjacent [`UserContent`][pydantic_ai.messages.UserContent] (a `str` or multi-modal content like an [`ImageUrl`][pydantic_ai.messages.ImageUrl]) is gathered into one [`UserPromptPart`][pydantic_ai.messages.UserPromptPart], and each [`ModelRequestPart`][pydantic_ai.messages.ModelRequestPart] (e.g. a [`SystemPromptPart`][pydantic_ai.messages.SystemPromptPart]) is coalesced with adjacent part-style items into one [`ModelRequest`][pydantic_ai.messages.ModelRequest]; a complete [`ModelRequest`][pydantic_ai.messages.ModelRequest] or [`ModelResponse`][pydantic_ai.messages.ModelResponse] is kept as its own message. The assembled sequence must end in a request. Calling with no positional args is a no-op. priority: When to deliver: `'asap'` (default) — at the earliest opportunity (next model request, or a redirect if the agent would otherwise end). In a realtime session, an active assistant response is allowed to finish before the content is sent; otherwise it is sent immediately. `'when_idle'` — only when the agent would otherwise end, after `'asap'` messages. In a realtime session, this means after the next response completes. Either way the model gets a turn on the delivered content, a `SystemPromptPart` included: it marks provenance, not silence. Returns: The `enqueue_id` of the queued message, echoed on the [`EnqueuedMessagesEvent`][pydantic_ai.messages.EnqueuedMessagesEvent] emitted when it's delivered, or `None` when there was nothing to enqueue (an empty call). Raises: UserError: If the run or realtime session has ended, or this `RunContext` isn't backed by a running agent's queue (e.g. the synthetic context from `Agent.system_prompt_parts`), since there'd be nowhere to deliver the message. Nz`enqueue` is only available during an agent run (from tools, capability hooks, or `AgentRun.enqueue`). This `RunContext` has no pending-message queue to drain.r)rrr from_contentrC enqueue_id)r<rcontentros r?enqueueRunContext.enqueuescR  (` !--wJJ ? $$W-!!!rAcvURRS5nUc [S5eUR5 g)uCancel the agent run this context belongs to. Safe to call from anywhere a `RunContext` is available — tools, `event_stream_handler`s, and capability hooks. This *requests* cancellation: it returns normally, and the calling code keeps running until its next `await`, where the cancellation is delivered — so the caller can still do cleanup, but its return value (e.g. a tool's result) is discarded. The run then stops what it is doing (the in-flight model request is torn down, sibling tool tasks are cancelled and drained, a suspended server-side job is best-effort cancelled) and ends with [`RunCancelled`][pydantic_ai.exceptions.RunCancelled], preserving everything that completed before the cancellation took effect in message history. Idempotent; a no-op once the run has finished. Cancellation is terminal: capability hooks may observe it and clean up, but cannot recover the run to success. Cancellation cannot forcibly stop synchronous code running in a worker thread; it may continue and perform side effects, although its result is discarded. Raises: UserError: If this `RunContext` isn't backed by a running agent (e.g. the synthetic context from `Agent.system_prompt_parts`, or across a durable-execution serialization boundary such as a Temporal activity). rNz`cancel` is only available during an agent run (from tools, event stream handlers, or capability hooks) in the same process as the run itself. This `RunContext` has no run to cancel.)__dict__rircancel)r< cancellations r?r RunContext.cancel5s>004}}/@/@/Q  :  rAr)rKr)rKr)rrrKrL)rKr)rKz float | NonerI)rKr)rzstr | ToolDefinitionrKr)rKzdict[str, ToolDefinition])rEr1rKr1)rEr3rKr3)rE1_messages.CustomEvent | _messages.CapabilityEventrKr)rrrrrKr)rKrL)TrMrNrOrPrQrxr rrrrlistrY ModelMessagerrrrrrrdictrrrrrrrrrrrrrrrrrrr\r]r^AgentStreamEventrlrrrrrrrarrDrvrrurrpropertyrrrrsetterrrrrrrrrrrrrrrr rdataclasses_no_defaults_repr__repr__rSrHrAr?r|r|sG- % Q O,!$U;Iz;\'+L$+ 6;4e5TE 2T?;?F 8?5-24 H^H^C_-`H*`8""Q:6FF60"'4'F#BSBJ#DcNCG^C1#L*#" Iz (E3N K Hc&$$K""o ND FFJ/"&OZ& '+H#*ACGN@G 5:$U4S1S-2$U,KM)KEJRV]bDcAcEJS$w}}"556UE!#A` INS)"<"<<=EI EGSXaelqSrPrJOW[bgIhFhX@EdY^@_=_BGWahmAn>n>BL:A05T/N,N HLODK IN^hHiLEi',CH&E8E&*{) ',CH&E8E ,1A[bg+h(hDIQU\aCbK@bJ  6- &  & 6- '  '  W W..>0 ' 'D  2 _- *  * Z Zcc"<^|WW EE MMdFd :dR,22" 2")2"  2"hB22HrAr|)rc zUb,[R"S[SS9 URSU5 [ U40UD6 g)Nr) stacklevelr)warningswarnrr__run_context_init)r<rkwargss r?(_run_context_init_with_capability_loadedr\sB$  : (  -/@Ad%f%rAzpydantic_ai.current_run_context)r-z"ContextVar[RunContext[Any] | None]_CURRENT_RUN_CONTEXTc*[R5$)zGet the current run context, if one is set. Returns: The current [`RunContext`][pydantic_ai.tools.RunContext], or `None` if not in an agent run. )r rirHrAr?get_current_run_contextr"zs # # %%rAc## [RU5nSv [RU5 g![RU5 f=f7f)z}Context manager to set the current run context. Args: run_context: The run context to set as current. Yields: None N)r rDreset) run_contexttokens r?set_current_run_contextr's< ! $ $[ 1E* ""5)""5)sA 3A A  A )rdrrErJrKrL)rdrrmz)AsyncIterable[_messages.AgentStreamEvent]rKz)AsyncIterator[_messages.AgentStreamEvent])r<rrrrrrKrL)rKzRunContext[Any] | None)r%rrKzGenerator[None])^ __future__r _annotationsr\ dataclassesrrcollections.abcrrrrrr contextlibr contextvarsr r functoolsr typingrrrropentelemetry.tracerrtyping_extensionsrrpydantic_ai._instrumentationrrrrrY_enqueuerrr _warningsr exceptionsrtuplerr_DurableOperationDispatch_cancelr rr!capabilities.abstractr"durable_exec._toolsetr#modelsr$rr%r&settingsr'rr(rr)rr*r+objectr,r/ CustomEventr1rZr3rrr5rgrp dataclassrsr|r;rrr rxr"r'rHrAr?r@s 2 bb%"8821H+LL3!$c3hc3h8 cNY(95%@')%, \6 F +5vQUV?~Y-B-BC -Y5N5NOY778&,B B"KB.B" d#]]$]* E40Q 3-.Q 31Q 3h''?C &  &1< &OR &  & &&?