"j' |%SSKJr SSKrSSKrSSKJrJr SSKJ r J r J r J r J r JrJr SSKJr SSKJrJrJr SSKJr SSKJrJr SS KJrJrJrJrJ r J!r! SSK"r"SS K#J$r$ SS K%J&r& SS K'J(r(J)r)J*r*J+r+ SS K,J-r- SSK.J/r/J0r0J1r1J2r2J3r4J5r5J6r6J7r7J8r9 SSK:J;r;JJ?r? SSK@JArA SSKBJCrC SSK2JDrD SSKEJFrFJGrG SSK6JHrHJIrIJJrJ SSKKJLrLJMrMJNrN SSKOJPrP SSKQJRrR SSK7JSrS SSKTJUrUJVrVJWrWJXrXJYrYJZrZ SSK[J\r\ \(a(SSK]J^r^ SSK_J`r` SSKaJbrb SS KcJdrdJereJfrfJgrgJhrhJiriJjrjJkrkJlrl \+"S!5rm\+"S"5rn\o"S5rp\+"S#5rq\ \X\US$/\ S4rrS%\sS&'\ \X\US$/S'4rtS%\sS('\u\v\4\ \X\U/\u\v\44-rw\0Rrx\xry\P\ \X\U/\P4-rz"S)S*\)S+S,9r{\ \r\/\ \M\F4r|S%\sS-'"S.S/\\F\ \4R\N\F-5r~"S0S1\\F\\~\F5r"S2S3\\U\F4\5r\"S4S555r\"S6S7\\U55r"S8S9\\U5rg):) annotationsN)ABCabstractmethod)AsyncGenerator AsyncIterable AsyncIterator AwaitableCallable GeneratorSequence)Executor)AbstractAsyncContextManagerasynccontextmanagercontextmanager) dataclass) FrameType TracebackType) TYPE_CHECKINGAnyGeneric TypeAliascastoverload)MemoryObjectReceiveStream) TypeAdapter)Self TypedDictTypeIsTypeVar)End) _agent_graph _instructions_utils exceptionsmessagesmodelsresult tool_managerusage)CancellationToken RunBindingprovide_run_binding) JsonSchema)types_from_output_spec)AgentCapability) RunCancelled) OutputDataT OutputSpec) AgentStream FinalResultStreamedRunResult)AgentRunAgentRunResultAgentRunResultEvent) ModelSettings) TemplateStr) ToolManager) AgentDepsTAgentNativeToolDeferredToolResults RunContextToolToolFuncEither)AbstractToolset) AgentSpec)CombinedCapability)InstrumentationSettings) AudioRetentionKnownRealtimeModelNameRealtimeClientSecret RealtimeModelRealtimeModelProfileRealtimeModelSettingsRealtimeProviderSessionRealtimeSession WebRTCAnswerTSRunOutputDataT)AsyncIterable[_messages.AgentStreamEvent]rEventStreamHandler)AsyncIterator[_messages.AgentStreamEvent]EventStreamProcessorc.\rSrSr%SrS\S'S\S'Srg) AgentRetriesmuPer-category retry budgets for an [`Agent`][pydantic_ai.agent.Agent]. Pass to `Agent(retries=...)` as a dict to set different budgets per category. A bare `int` is shorthand for setting both `tools` and `output` to that value — the same at every call site (`Agent(retries=N)`, `run()`, `iter()`, `override()`, and a run-time `spec`). To set only one budget, pass a dict, e.g. `retries={'tools': ...}` or `retries={'output': ...}`. Keys: tools: Default number of retries for tool calls before raising an error. Applies to function tools, output tools, and MCP tools, unless a more specific per-tool or per-toolset limit is set. output: Maximum number of retries for output validation. On the text path this is a global per-run budget; on the tool path it is the default per-tool `max_retries` for each output tool, overridable via [`ToolOutput(max_retries=...)`][pydantic_ai.output.ToolOutput.max_retries]. inttoolsoutputN)__name__ __module__ __qualname____firstlineno____doc____annotations____static_attributes__r]W/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/agent/abstract.pyrXrXms$ J KrerXF)total_RunStreamEventsRunnerc\rSrSrSrSSjrSSjrSSjrSSjrSSjr SSjr \ SS j5r \ SS j5r SS jrSS jrSS jrSSjrSrg)AgentRunEventsaMThe event iterator returned by [`run_stream_events()`][pydantic_ai.agent.AbstractAgent.run_stream_events]. Lazily starts a background `run()` task on the first `__anext__()` and forwards its events over a memory object stream, ending with a single trailing `AgentRunResultEvent` that carries the run's result. Entering the context manager without iterating therefore never starts a run (https://github.com/pydantic/pydantic-ai/issues/6162). This is a hand-written iterator class rather than an `async def` generator on purpose: generator cleanup runs by throwing `GeneratorExit` into the suspended frame during finalization, which on Python 3.10/3.11 can resume the frame under a different `Context` and raise the `pydantic_ai.current_run_context` token error (https://github.com/pydantic/pydantic-ai/issues/5132). Driving cleanup explicitly through `aclose()` keeps teardown in the caller's task and context. The handle can cancel the whole run and exposes its live messages and usage after iteration has started. After successful completion, `result` contains the final run result. `cancel()` and the state accessors (`all_messages()`, `new_messages()`, `usage`) require the run to be driven through the standard [`Agent.iter()`][pydantic_ai.agent.Agent.iter] path, which binds the run to this handle. The built-in `Agent` and the durable wrapper agents do this; a custom [`AbstractAgent`][pydantic_ai.agent.AbstractAgent] subclass whose `run()`/`iter()` chain doesn't consume that binding gets a `cancel()` that silently no-ops and state accessors that raise `UserError`, even after iteration has started. cfXl[5UlSUlSUlSUlSUlg)NF) _run_agentr,_binding_receive_stream_task_result_yielded_closedself run_agents rf__init__AgentRunEvents.__init__s7#"    HL $ recU$Nr]rts rf __aiter__AgentRunEvents.__aiter__s recV# UR(dUR(a[eURc0URR R (a [S5eUR5IShvN URceURceURR5IShvN $NEN![RaM URR5IShvN SUlURIShvN n[U5s$f=f7f)NzThe agent run was cancelled.T)rrrqStopAsyncIterationrprn cancellationcancel_requestedr1_ensure_startedroreceiveanyio EndOfStreamacloser9)rtr(s rf __anext__AgentRunEvents.__anext__s <<4//$ $ :: $--"<"<"M"M=> >""$$$##///zz%%% /--5577 7 % 8   /&&--/ / /#'D ::%%F&v. .  /s`A9D);C<"D)C<C=CD)C1D&6C97D&DD&#D)%D&&D)cLURRR5 g)uRequest cancellation of the whole run. This method is idempotent, is a no-op after completion, and is safe to call from another task (e.g. a TUI's key handler) or thread — the underlying controller marshals onto the run's event loop, just like [`CancellationToken.cancel()`][pydantic_ai.CancellationToken.cancel]. It does not affect external cancellation of the consumer task. If iteration continues, cancellation surfaces as [`RunCancelled`][pydantic_ai.exceptions.RunCancelled]; leaving the context instead performs quiet teardown. Cancelling before the first iteration prevents the run from starting at all; iterating afterwards raises `RunCancelled` with empty `messages`. N)rnrcancelrzs rfrAgentRunEvents.cancels ""))+rec>UR5R5$)zReturn all messages from the run, including messages supplied as history. Raises `UserError` if accessed before the first iteration has started the run. ) _agent_run all_messagesrzs rfrAgentRunEvents.all_messages  --//rec>UR5R5$)zyReturn only messages created by the run. Raises `UserError` if accessed before the first iteration has started the run. )r new_messagesrzs rfrAgentRunEvents.new_messagesrrec6UR5R$)zpReturn the run's current usage. Raises `UserError` if accessed before the first iteration has started the run. )rr*rzs rfr*AgentRunEvents.usages  &&&recURnUbKUR5(a6UR5(d!UR5cUR 5$g)zAReturn the successful run result once complete, otherwise `None`.N)rpdone cancelled exceptionr()rttasks rfr(AgentRunEvents.resultsDzz   DNN4D4DIYIa;;= recdURRnUc[R"S5eU$)Nz2The run has not started; iterate the events first.)rn agent_runr% UserError)rtrs rfrAgentRunEvents._agent_runs/MM++  &&'[\ \recURRnUcg[R"SURR URR 5RU5 g)avAttach the run's state to an external cancellation of the consumer task. The background run's own `CancelledError` (carrying the state attached by the translation funnel) is consumed by `aclose()`'s drain, so the state is rebuilt from the live run and attached to the consumer's propagating exception for `RunCancelled.from_cancellation()`. No-op if the run never started. Nz@The agent run was cancelled by an external asyncio cancellation.)rnrr"run_cancelled_snapshotctxstatedeps _attach_to)rtexcrs rf_attach_run_state AgentRunEvents._attach_run_statesRMM++   ++ N MM   MM    *S/rec^# UR(agSUlURbURR5 URb"URR 5IShvN URb)[ R "UR5IShvN ggN;N7f)zRCancel the background run (if started) and close the receive stream, idempotently.NT)rrrprrorr$cancel_and_drainrzs rfrAgentRunEvents.acloses <<   :: ! JJ       +&&--/ / / :: !))$**5 5 5 " 0 5s$A+B--B).4B-"B+#B-+B-c^^^# TRbg[R[R[ [ -"5umnUTlSU4SjjmSUUU4Sjjn[R"U"55Tlg7f)Ncd># UShvN nTRU5IShvN M$NN g7fry)send)_eventsevent send_streams rfevent_stream_handler.event_stream_handler%s1% .e!&&u--- .- &s(0.*.0,0.00cB># TIShvN [TR5 TRT5IShvN nSSS5 [R"5 WsSSS5IShvN $NcN6!,(df  N:=fN!,IShvN (df  g=f7fry)r-rnrmr$raise_if_cancelling)r(rrtrs rfru1AgentRunEvents._ensure_started..run_agent)s_"{(7#'??3G#HHF8 **,#{{H87#{{{sjBA.BBA2A0A2B B(B)B0A22 B <BBB B BB)rzRunContext[Any]rrSreturnNone)rAgentRunResult[OutputDataT]) rprcreate_memory_object_stream _messagesAgentStreamEventr9r2roasyncio create_task)rtreceive_streamrurrs` @@rfrAgentRunEvents._ensure_startedsr :: ! ',&G&G  & &)<[)I I' ' # ^ . .  ((5 sBB)rnrrrorqrmrpNruz#_RunStreamEventsRunner[OutputDataT]rr)rzLAsyncIterator[_messages.AgentStreamEvent | AgentRunResultEvent[OutputDataT]])rz=_messages.AgentStreamEvent | AgentRunResultEvent[OutputDataT]rr)rlist[_messages.ModelMessage])rz_usage.RunUsage)rz"AgentRunResult[OutputDataT] | None)rzAgentRun[Any, OutputDataT])r BaseExceptionrr)r^r_r`rarbrvr{rrrrpropertyr*r(rrrrrdr]rerfrjrjsa. /* ,00'' "6&6rerjcF\rSrSrSrSSjrS SjrS SjrSrg) _RunStreamEventsContexti7aThe async context manager returned by [`run_stream_events()`][pydantic_ai.agent.AbstractAgent.run_stream_events]. Hands out a single `AgentRunEvents` on entry and closes it on exit, so an early `break` out of the event loop still cancels and drains the background run. cXlSUlgry)rm _iteratorrss rfrv _RunStreamEventsContext.__init__>s#=Arec# URb [S5e[UR5UlUR$7f)NzF`run_stream_events()` context manager cannot be entered more than once)r RuntimeErrorrjrmrzs rf __aenter__"_RunStreamEventsContext.__aenter__Bs7 >> %gh h'8~~s?Ac# URb^URR5IShvN [U[R5(aURR U5 gggNA7fry)rr isinstancerCancelledErrorr)rtexc_type exc_value tracebacks rf __aexit__!_RunStreamEventsContext.__aexit__Ks[ >> %..'') ) ))W%;%;<<00;= & )s+A1A/AA1)rrmNr)rzAgentRunEvents[OutputDataT])rztype[BaseException] | NonerzBaseException | NonerzTracebackType | Nonerr) r^r_r`rarbrvrrrdr]rerfrr7s= B <, <( <( <  j5r*\SmS?j5r+\SnS@j5r,SoSpSAjjr-SoSpSBjjr.SCr/g)q AbstractAgentiZzAbstract superclass for [`Agent`][pydantic_ai.agent.Agent], [`WrapperAgent`][pydantic_ai.agent.WrapperAgent], and your own custom agent implementations.c[e)z,The default model configured for this agent.NotImplementedErrorrzs rfmodelAbstractAgent.model] "!rec[e)zThe name of the agent, used for logging. If `None`, we try to infer the agent name from the call frame when the agent is first run. rrzs rfnameAbstractAgent.namec "!rec[e)z,Set the name of the agent, used for logging.rrtvalues rfrrlrrec[e)z*A human-readable description of the agent.rrzs rf descriptionAbstractAgent.descriptionrrrec[e)z!Set the description of the agent.rrs rfrrxrrec[e)z+The type of dependencies used by the agent.rrzs rf deps_typeAbstractAgent.deps_type~rrec[e)zjThe type of data output by agent runs, used to validate the data returned by the model, defaults to `str`.rrzs rf output_typeAbstractAgent.output_typerrec[e)zcOptional handler for events from the model's streaming response and the agent's execution of tools.rrzs rfr"AbstractAgent.event_stream_handlerrrec[e)zIThe root capability of the agent, containing all registered capabilities.rrzs rfroot_capabilityAbstractAgent.root_capabilitys "!recg)z sc"Uc URn[US9n/nUH3n[U5RSS9nXS;dM"UR U5 M5 [ U5S:XaUS$[ R"U5up6SU0nU(aXeS'U$)zThe output return JSON schema.) output_spec serializationmoderanyOfz$defs)rr/r json_schemaappendlenr$merge_json_schema_defs)rtr return_types json_schemas return_typerall_defss rfoutput_json_schema AbstractAgent.output_json_schemas  **K-+F )+ 'K%k2>>O>TK.##K0( |  !? "%+%B%B<%P "L'. &=K'/G$ reTrrdeferred_tool_resultsconversation_idrun_idr instructionsrr usage_limitscancellation_tokenr*metadataretries infer_namerr capabilitiesspecc # g7fryr]rt user_promptrrrrrrrrrrrr*rrrrrrrs rfrunAbstractAgent.runs 0'*)rrrrrrrrrrr*rrrrrrrc # g7fryr]rs rfr!r"s 0*-r#c^^^# U(a1TRc$TR[R"55 U=(d TRnTR UUUUUUUUU U U U U UUUUUS9IShvN mSnU=mbSUUU4SjjnUnTR n[U[5(d\TRbONUbTRUU5IShvN nOTRU5IShvN n[U[5(dM\SSS5IShvN TRcS5eTR$NNgNON*!,IShvN (df  N?=f7f)aRun the agent with a user prompt in async mode. This method builds an internal agent graph (using system prompts, tools and output schemas) and then runs the graph to completion. The result of the run is returned. Example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-5.2') async def main(): agent_run = await agent.run('What is the capital of France?') print(agent_run.output) #> The capital of France is Paris. ``` Args: user_prompt: User input to start/continue the conversation. output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no output validators since output validators would expect an argument that matches the agent's output type. message_history: History of the conversation so far. deferred_tool_results: Optional results for deferred tool calls in the message history. conversation_id: ID of the conversation this run belongs to. Pass `'new'` to start a fresh conversation, ignoring any `conversation_id` already on `message_history`. If omitted, falls back to the most recent `conversation_id` on `message_history` or a freshly generated UUID7. run_id: Optional ID for this agent run. Unlike `conversation_id`, never inherited from `message_history`. Passing an empty string, or a value that already appears on `message_history`, raises `UserError` because both break `new_messages()`; use `conversation_id` to correlate across turns or deferred-tool resume. If omitted, a fresh UUID7 is generated. model: Optional model to use for this run, required if `model` was not set when creating the agent. instructions: Optional additional instructions to use for this run. deps: Optional dependencies to use for this run. model_settings: Optional settings to use for this model's request, or a callable that receives [`RunContext`][pydantic_ai.tools.RunContext] and returns settings. Callables are called before each model request, allowing dynamic per-step settings. usage_limits: Optional limits on model request count or token usage. cancellation_token: Token used to cancel this run from another task or thread. Single-use: mint a fresh token per run, as a reused (already-cancelled) token prevents the run from starting. usage: Optional usage to start with, useful for resuming a conversation or agents used in tools. metadata: Optional metadata to attach to this run. Accepts a dictionary or a callable taking [`RunContext`][pydantic_ai.tools.RunContext]; merged with the agent's configured metadata. retries: Override the agent-level retry budgets for this run. Pass an `int` to override both the tool-retry and output budgets, or an [`AgentRetries`][pydantic_ai.AgentRetries] dict to override just one (e.g. `retries={'tools': 3}`). See [`Agent.__init__`][pydantic_ai.agent.Agent.__init__] for semantics of the two enforcement paths. infer_name: Whether to try to infer the agent name from the call frame if it's not set. toolsets: Optional additional toolsets for this run. event_stream_handler: Optional handler for events from the model's streaming response and the agent's execution of tools to use for this run. Under a durability capability, this per-run handler runs workflow-side; model events are replayed after each model request completes. For handler I/O inside the durable boundary, pass `event_stream_handler=` to the durability capability. capabilities: Optional additional [capabilities](https://pydantic.dev/docs/ai/capabilities/overview/) for this run, merged with the agent's configured capabilities. spec: Optional agent spec to apply for this run. At run time, spec values are additive. Returns: The result of the run. N)r rrrrrrrrrrrr*rrrrrc># TRU5(dTRU5(aaURTR5IShvN n[R "TR5nT"X!5IShvN UShvN nM TR U5IShvN $NZN,N# SSS5IShvN M3!,IShvN (df  NJ=fN87fry)is_model_request_nodeis_call_tools_nodestreamrr"build_run_context_advance_graph)nr)run_ctxr_handlerrrts rf_stream_and_advance.AbstractAgent.run.._stream_and_advance~s11!448O8OPQ8R8R$%88IMM#:#:f&2&D&DY]]&SG"*7";;;,2%a $!*!9!9!!<<<$;;%6 $;#:#:#:#:#:=sA C B*C ,C?B,CB0 B. B0CC %C&C ,C.B00C1 C <B?=C C C CC z%The graph run did not finish properly)r,z'_agent_graph.AgentNode[AgentDepsT, Any]rz?_agent_graph.AgentNode[AgentDepsT, Any] | End[FinalResult[Any]]) r _infer_nameinspect currentframeriter next_noderr r(_run_node_with_hooksnext)rtr rrrrrrrrrrrr*rrrrrrr _stream_stepr/noder.rs` @@rfr!r" sT $))+   W113 43Pt7P7P99##+"7+%)%1%%  & 10==>=T== 3 &&D s++##/+!*!?!?l!SSD!*!55D!s++k  |+T-TT+ tT5y    smA2E"7E8E";AEEE4E5E E"E%E"EEE"EE  EE"cgryr]rs rfrun_syncAbstractAgent.run_syncs0'*recgryr]rs rfr;r<s0*-rec[R"5 U(a1URc$UR[R "55 [R "URUUUUUUUUU U U U U UUSUUUUS95$)a)Synchronously run the agent with a user prompt. This is a convenience method that wraps [`self.run`][pydantic_ai.agent.AbstractAgent.run] with `loop.run_until_complete(...)`. You therefore can't use this method inside async code or if there's an active event loop. This method cannot be used inside a synchronous tool, output function, or other function called during an agent run. To delegate to another agent, make the function `async def` and `await` [`self.run`][pydantic_ai.agent.AbstractAgent.run] instead. See [Agent delegation](../multi-agent-applications.md#agent-delegation). Example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-5.2') result_sync = agent.run_sync('What is the capital of Italy?') print(result_sync.output) #> The capital of Italy is Rome. ``` Args: user_prompt: User input to start/continue the conversation. output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no output validators since output validators would expect an argument that matches the agent's output type. message_history: History of the conversation so far. deferred_tool_results: Optional results for deferred tool calls in the message history. conversation_id: ID of the conversation this run belongs to. Pass `'new'` to start a fresh conversation, ignoring any `conversation_id` already on `message_history`. If omitted, falls back to the most recent `conversation_id` on `message_history` or a freshly generated UUID7. run_id: Optional ID for this agent run. Unlike `conversation_id`, never inherited from `message_history`. Passing an empty string, or a value that already appears on `message_history`, raises `UserError` because both break `new_messages()`; use `conversation_id` to correlate across turns or deferred-tool resume. If omitted, a fresh UUID7 is generated. model: Optional model to use for this run, required if `model` was not set when creating the agent. instructions: Optional additional instructions to use for this run. deps: Optional dependencies to use for this run. model_settings: Optional settings to use for this model's request, or a callable that receives [`RunContext`][pydantic_ai.tools.RunContext] and returns settings. Callables are called before each model request, allowing dynamic per-step settings. usage_limits: Optional limits on model request count or token usage. cancellation_token: Token used to cancel this run from another task or thread. Single-use: mint a fresh token per run, as a reused (already-cancelled) token prevents the run from starting. usage: Optional usage to start with, useful for resuming a conversation or agents used in tools. metadata: Optional metadata to attach to this run. Accepts a dictionary or a callable taking [`RunContext`][pydantic_ai.tools.RunContext]; merged with the agent's configured metadata. retries: Override the agent-level retry budgets for this run. Pass an `int` to override both the tool-retry and output budgets, or an [`AgentRetries`][pydantic_ai.AgentRetries] dict to override just one (e.g. `retries={'tools': 3}`). See [`Agent.__init__`][pydantic_ai.agent.Agent.__init__] for semantics of the two enforcement paths. infer_name: Whether to try to infer the agent name from the call frame if it's not set. toolsets: Optional additional toolsets for this run. event_stream_handler: Optional handler for events from the model's streaming response and the agent's execution of tools to use for this run. Under a durability capability, this per-run handler runs workflow-side; model events are replayed after each model request completes. For handler I/O inside the durable boundary, pass `event_stream_handler=` to the durability capability. capabilities: Optional additional [capabilities](https://pydantic.dev/docs/ai/capabilities/overview/) for this run, merged with the agent's configured capabilities. spec: Optional agent spec to apply for this run. At run time, spec values are additive. Returns: The result of the run. Fr)r$check_no_nested_sync_runrr1r2r3run_until_completer!rs rfr;r<s\ '') $))+   W113 4(( HH' /&; /)-)#5! !%9))    recgryr]rs rf run_streamAbstractAgent.run_stream=s 0Z]recgryr]rs rfrBrCWs 0]`rec. ^ ^!^"^#^$^%# U(aDURc7[R"5=n(aURUR5 U=(d UR nSnUR UUUUUUUU UU U U U UUSUUUS9IShvN m T RbNT Rm#[T#RRT#RRT RS97v SnT Rn[U[ R"5(deUnU(GdT Rm#[ R$"T#5nT#RR&nUR)UUS9IShvN nUR+U5(aQUR-T#5IShvN m%Sm"S U"4SjjnU"T%5nUbU"UU5IShvN UShvN nM UR7U5(aEUR-T R5IShvN m%UbU"UT%5IShvN T%ShvN nM [ R$"T#5nT R9UUT R:5IShvN n[U[<5(aPT RbC[T#RRT#RRT RS97v SnOf[U[ R>5(d[@RB"S 5e[E[ R>[F[F4U5nU(dGMSSS5IShvN U(d[@RB"S 5egGNGNGNGNGN T"b[/ST"R0T"R25m!SnT#RRR55m$S U U!U#U$U%4Sjjn[T$T#RRT%U57v SSS5IShvN MSSS5IShvN GM!,IShvN (df  GN=fGN(GNGN SSS5IShvN GM !,IShvN (df  GN8=fGNGN-!,IShvN (df  GNC=f7f) aRun the agent with a user prompt in async streaming mode. This method builds an internal agent graph (using system prompts, tools and output schemas) and then runs the graph until the model produces output matching the `output_type`, for example text or structured data. At this point, a streaming run result object is yielded from which you can stream the output as it comes in, and -- once this output has completed streaming -- get the complete output, message history, and usage. As this method will consider the first output matching the `output_type` to be the final output, it will stop running the agent graph and will not execute any tool calls made by the model after this "final" output. If you want to always run the agent graph to completion and stream events and output at the same time, use [`agent.run()`][pydantic_ai.agent.AbstractAgent.run] with an `event_stream_handler` or [`agent.iter()`][pydantic_ai.agent.AbstractAgent.iter] instead. Example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-5.2') async def main(): async with agent.run_stream('What is the capital of the UK?') as response: print(await response.get_output()) #> The capital of the UK is London. ``` Args: user_prompt: User input to start/continue the conversation. output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no output validators since output validators would expect an argument that matches the agent's output type. message_history: History of the conversation so far. deferred_tool_results: Optional results for deferred tool calls in the message history. conversation_id: ID of the conversation this run belongs to. Pass `'new'` to start a fresh conversation, ignoring any `conversation_id` already on `message_history`. If omitted, falls back to the most recent `conversation_id` on `message_history` or a freshly generated UUID7. run_id: Optional ID for this agent run. Unlike `conversation_id`, never inherited from `message_history`. Passing an empty string, or a value that already appears on `message_history`, raises `UserError` because both break `new_messages()`; use `conversation_id` to correlate across turns or deferred-tool resume. If omitted, a fresh UUID7 is generated. model: Optional model to use for this run, required if `model` was not set when creating the agent. instructions: Optional additional instructions to use for this run. deps: Optional dependencies to use for this run. model_settings: Optional settings to use for this model's request, or a callable that receives [`RunContext`][pydantic_ai.tools.RunContext] and returns settings. Callables are called before each model request, allowing dynamic per-step settings. usage_limits: Optional limits on model request count or token usage. cancellation_token: Token used to cancel this run from another task or thread. Single-use: mint a fresh token per run, as a reused (already-cancelled) token prevents the run from starting. usage: Optional usage to start with, useful for resuming a conversation or agents used in tools. metadata: Optional metadata to attach to this run. Accepts a dictionary or a callable taking [`RunContext`][pydantic_ai.tools.RunContext]; merged with the agent's configured metadata. retries: Override the agent-level retry budgets for this run. Pass an `int` to override both the tool-retry and output budgets, or an [`AgentRetries`][pydantic_ai.AgentRetries] dict to override just one (e.g. `retries={'tools': 3}`). See [`Agent.__init__`][pydantic_ai.agent.Agent.__init__] for semantics of the two enforcement paths. infer_name: Whether to try to infer the agent name from the call frame if it's not set. toolsets: Optional additional toolsets for this run. event_stream_handler: Optional handler for events from the model's streaming response and the agent's execution of tools to use for this run. Under a durability capability, this per-run handler runs workflow-side; model events are replayed after each model request completes. For handler I/O inside the durable boundary, pass `event_stream_handler=` to the durability capability. It will receive all the events up until the final result is found, which you can then read or stream from inside the context manager. Note that it does _not_ receive any events after the final result is found. capabilities: Optional additional [capabilities](https://pydantic.dev/docs/ai/capabilities/overview/) for this run, merged with the agent's configured capabilities. spec: Optional agent spec to apply for this run. At run time, spec values are additive. Returns: The result of the run. NF)rrrrrrrrrrrr*rrrrrr) run_resultTr9c~># UShvN nU7v [U[R5(dM/Um gN. g7fry)rrFinalResultEvent)r)rfinal_result_events rfstream_to_final1AbstractAgent.run_stream..stream_to_finals:06*e&+ #-eY5O5O#P#P9>$6$) *vs =;9;#==;=c P># [TR5IShvN TRTR5m/n[R "TR RTRRSSTTUS9ShvN nM NmN U(aaTR[R"UTRRTRR[ R""5S95 TR%[R&"T55IShvN g7f)zCalled when the stream has completed. The model response will have been added to messages by now by `StreamedRunResult._marked_completed`. N)r) tool_callstool_call_resultstool_call_metadata final_resultr output_parts)rr timestamp)r5 get_output tool_name tool_call_idr"process_tool_callsrr)responserNr r ModelRequestrrrr$now_utcr7SetFinalResult)parts_eventrrQ graph_ctxr&r)s rf on_complete-AbstractAgent.run_stream..on_completes0;*0*;*;*=$=|?U?UWcWpWp0" KM4@4S4S1:1L1L/5/I/I6:7;1=(1165" !)&%)+%> !)5"$)$,OO(1(>(>,13(Q.Q2Q 3Q6Q96Q:/Q40C Q:? R Q7 #R0Q:3Q:6P 9M<QQQ Q:QQ:Q1 Q" Q1 , Q:7R:RR  R Rrrrrrrrrrrr*rrrrrrrcgryr]rtr rrrrrrrrrrr*rrrrrrrs rfrun_stream_syncAbstractAgent.run_stream_syncqs .ADre)rrrrrrrrrr*rrrrrrrcgryr]rps rfrqrr .DGrec[R"5 U(a1URc$UR[R "55 [ R"URUUUUUUUUU U U U U USUUUUS95$)aRun the agent with a user prompt in sync streaming mode. This is a convenience method that wraps [`run_stream()`][pydantic_ai.agent.AbstractAgent.run_stream], running all of the agent's async work on the caller's event loop while keeping context-manager and iterator lifecycles in stable tasks. You therefore can't use this method inside async code or if there's an active event loop. Like [`run_sync()`][pydantic_ai.agent.AbstractAgent.run_sync], this method cannot be used inside a synchronous tool, output function, or other function called during an agent run. See [Agent delegation](../multi-agent-applications.md#agent-delegation). The returned [`StreamedRunResultSync`][pydantic_ai.result.StreamedRunResultSync] is a synchronous context manager and should be used and closed on the thread where it was created. Use a `with` block so the stream is cleaned up when you're done. This method builds an internal agent graph (using system prompts, tools and output schemas) and then runs the graph until the model produces output matching the `output_type`, for example text or structured data. At this point, a streaming run result object is yielded from which you can stream the output as it comes in, and -- once this output has completed streaming -- get the complete output, message history, and usage. As this method will consider the first output matching the `output_type` to be the final output, it will stop running the agent graph and will not execute any tool calls made by the model after this "final" output. If you want to always run the agent graph to completion and stream events and output at the same time, use [`agent.run()`][pydantic_ai.agent.AbstractAgent.run] with an `event_stream_handler` or [`agent.iter()`][pydantic_ai.agent.AbstractAgent.iter] instead. Example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-5.2') def main(): with agent.run_stream_sync('What is the capital of the UK?') as response: print(response.get_output()) #> The capital of the UK is London. ``` Args: user_prompt: User input to start/continue the conversation. output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no output validators since output validators would expect an argument that matches the agent's output type. message_history: History of the conversation so far. deferred_tool_results: Optional results for deferred tool calls in the message history. conversation_id: ID of the conversation this run belongs to. Pass `'new'` to start a fresh conversation, ignoring any `conversation_id` already on `message_history`. If omitted, falls back to the most recent `conversation_id` on `message_history` or a freshly generated UUID7. run_id: Optional ID for this agent run. Unlike `conversation_id`, never inherited from `message_history`. Passing an empty string, or a value that already appears on `message_history`, raises `UserError` because both break `new_messages()`; use `conversation_id` to correlate across turns or deferred-tool resume. If omitted, a fresh UUID7 is generated. model: Optional model to use for this run, required if `model` was not set when creating the agent. deps: Optional dependencies to use for this run. model_settings: Optional settings to use for this model's request, or a callable that receives [`RunContext`][pydantic_ai.tools.RunContext] and returns settings. Callables are called before each model request, allowing dynamic per-step settings. usage_limits: Optional limits on model request count or token usage. cancellation_token: Token used to cancel this run from another task or thread. Single-use: mint a fresh token per run, as a reused (already-cancelled) token prevents the run from starting. usage: Optional usage to start with, useful for resuming a conversation or agents used in tools. metadata: Optional metadata to attach to this run. Accepts a dictionary or a callable taking [`RunContext`][pydantic_ai.tools.RunContext]; merged with the agent's configured metadata. retries: Override the agent-level retry budgets for this run. Pass an `int` to override both the tool-retry and output budgets, or an [`AgentRetries`][pydantic_ai.AgentRetries] dict to override just one (e.g. `retries={'tools': 3}`). See [`Agent.__init__`][pydantic_ai.agent.Agent.__init__] for semantics of the two enforcement paths. infer_name: Whether to try to infer the agent name from the call frame if it's not set. toolsets: Optional additional toolsets for this run. event_stream_handler: Optional handler for events from the model's streaming response and the agent's execution of tools to use for this run. Under a durability capability, this per-run handler runs workflow-side; model events are replayed after each model request completes. For handler I/O inside the durable boundary, pass `event_stream_handler=` to the durability capability. It will receive all the events up until the final result is found, which you can then read or stream from inside the context manager. Note that it does _not_ receive any events after the final result is found. capabilities: Optional additional [capabilities](https://pydantic.dev/docs/ai/capabilities/overview/) for this run, merged with the agent's configured capabilities. spec: Optional agent spec to apply for this run. At run time, spec values are additive. Returns: The result of the run. Frn) r$r?rr1r2r3r(StreamedRunResultSyncrBrps rfrqrrs| '') $))+   W113 4++ OO' /&; /-)#5! !%9)'    re)rrrrrrrrrrrr*rrrrrrcgryr]rtr rrrrrrrrrrrr*rrrrrrs rfrun_stream_eventsAbstractAgent.run_stream_eventsrtre)rrrrrrrrrrr*rrrrrrcgryr]rxs rfryrz7s .GJrec^^^^^^^^^^ ^ ^ ^ ^ ^^^^^U(a1TRc$TR[R"55 SU UUUU UUUUU UUUUUUU U U4Sjjn[ U5$)aRun the agent with a user prompt in async mode and stream events from the run. This is a convenience method that wraps [`self.run`][pydantic_ai.agent.AbstractAgent.run] and uses the `event_stream_handler` kwarg to get a stream of events from the run. The background run starts on the first iteration of the event handle, not on entering the context manager, so entering and exiting without iterating never calls the model. The handle can cancel the whole run and access its messages, usage, and completed result. Must be used as an async context manager so the background run task is deterministically cleaned up when the consumer stops iterating early. Example: ```python from pydantic_ai import Agent, AgentRunResultEvent, AgentStreamEvent agent = Agent('openai:gpt-5.2') async def main(): collected: list[AgentStreamEvent | AgentRunResultEvent] = [] async with agent.run_stream_events('What is the capital of France?') as events: async for event in events: collected.append(event) print(collected) ''' [ PartStartEvent(index=0, part=TextPart(content='The capital of ')), FinalResultEvent(tool_name=None, tool_call_id=None), PartDeltaEvent(index=0, delta=TextPartDelta(content_delta='France is Paris. ')), PartEndEvent( index=0, part=TextPart(content='The capital of France is Paris. ') ), AgentRunResultEvent( result=AgentRunResult(output='The capital of France is Paris. ') ), ] ''' ``` Arguments are the same as for [`self.run`][pydantic_ai.agent.AbstractAgent.run], except that `event_stream_handler` is now allowed. Args: user_prompt: User input to start/continue the conversation. output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no output validators since output validators would expect an argument that matches the agent's output type. message_history: History of the conversation so far. deferred_tool_results: Optional results for deferred tool calls in the message history. conversation_id: ID of the conversation this run belongs to. Pass `'new'` to start a fresh conversation, ignoring any `conversation_id` already on `message_history`. If omitted, falls back to the most recent `conversation_id` on `message_history` or a freshly generated UUID7. run_id: Optional ID for this agent run. Unlike `conversation_id`, never inherited from `message_history`. Passing an empty string, or a value that already appears on `message_history`, raises `UserError` because both break `new_messages()`; use `conversation_id` to correlate across turns or deferred-tool resume. If omitted, a fresh UUID7 is generated. model: Optional model to use for this run, required if `model` was not set when creating the agent. instructions: Optional additional instructions to use for this run. deps: Optional dependencies to use for this run. model_settings: Optional settings to use for this model's request, or a callable that receives [`RunContext`][pydantic_ai.tools.RunContext] and returns settings. Callables are called before each model request, allowing dynamic per-step settings. usage_limits: Optional limits on model request count or token usage. cancellation_token: Token used to cancel this run from another task or thread. Single-use: mint a fresh token per run, as a reused (already-cancelled) token prevents the run from starting. usage: Optional usage to start with, useful for resuming a conversation or agents used in tools. metadata: Optional metadata to attach to this run. Accepts a dictionary or a callable taking [`RunContext`][pydantic_ai.tools.RunContext]; merged with the agent's configured metadata. retries: Override the agent-level retry budgets for this run. Pass an `int` to override both the tool-retry and output budgets, or an [`AgentRetries`][pydantic_ai.AgentRetries] dict to override just one (e.g. `retries={'tools': 3}`). See [`Agent.__init__`][pydantic_ai.agent.Agent.__init__] for semantics of the two enforcement paths. infer_name: Whether to try to infer the agent name from the call frame if it's not set. toolsets: Optional additional toolsets for this run. capabilities: Optional additional [capabilities](https://pydantic.dev/docs/ai/capabilities/overview/) for this run, merged with the agent's configured capabilities. spec: Optional agent spec to apply for this run. At run time, spec values are additive. Returns: An async context manager that yields an [`AgentRunEvents`][pydantic_ai.agent.AgentRunEvents] handle over `AgentStreamEvent`s ending with a final `AgentRunResultEvent` carrying the run result. cd># TRTT TTTT T TTT TTTTT STUTTS9IShvN $N7f)NFr)r!)rrrrrrrrrrrrrrrtrrr*rr s rfru2AbstractAgent.run_stream_events..run_agentsb' /&; /)-)#5! !%9))" s &0.0)rzEventStreamHandler[AgentDepsT]rAgentRunResult[Any])rr1r2r3r)rtr rrrrrrrrrrrr*rrrrrrrus```````````````` ``` rfryrzPsLF $))+   W113 4    0'y11recgryr]rxs rfr4AbstractAgent.iters .JMrecgryr]rxs rfr4rs .MPrec# [e7f)aA contextmanager which can be used to iterate over the agent graph's nodes as they are executed. This method builds an internal agent graph (using system prompts, tools and output schemas) and then returns an `AgentRun` object. The `AgentRun` can be used to async-iterate over the nodes of the graph as they are executed. This is the API to use if you want to consume the outputs coming from each LLM model response, or the stream of events coming from the execution of tools. The `AgentRun` also provides methods to access the full message history, new messages, and usage statistics, and the final result of the run once it has completed. For more details, see the documentation of `AgentRun`. Example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-5.2') async def main(): nodes = [] async with agent.iter('What is the capital of France?') as agent_run: async for node in agent_run: nodes.append(node) print(nodes) ''' [ UserPromptNode( user_prompt='What is the capital of France?', instructions_functions=[], system_prompts=(), system_prompt_functions=[], system_prompt_dynamic_functions={}, ), ModelRequestNode( request=ModelRequest( parts=[ UserPromptPart( content='What is the capital of France?', timestamp=datetime.datetime(...), ) ], timestamp=datetime.datetime(...), run_id='...', conversation_id='...', ) ), CallToolsNode( model_response=ModelResponse( parts=[TextPart(content='The capital of France is Paris.')], usage=RequestUsage( cost=Decimal('0.000196'), input_tokens=56, output_tokens=7 ), model_name='gpt-5.2', timestamp=datetime.datetime(...), run_id='...', conversation_id='...', ) ), End(data=FinalResult(output='The capital of France is Paris.')), ] ''' print(agent_run.result.output) #> The capital of France is Paris. ``` Args: user_prompt: User input to start/continue the conversation. output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no output validators since output validators would expect an argument that matches the agent's output type. message_history: History of the conversation so far. deferred_tool_results: Optional results for deferred tool calls in the message history. conversation_id: ID of the conversation this run belongs to. Pass `'new'` to start a fresh conversation, ignoring any `conversation_id` already on `message_history`. If omitted, falls back to the most recent `conversation_id` on `message_history` or a freshly generated UUID7. run_id: Optional ID for this agent run. Unlike `conversation_id`, never inherited from `message_history`. Passing an empty string, or a value that already appears on `message_history`, raises `UserError` because both break `new_messages()`; use `conversation_id` to correlate across turns or deferred-tool resume. If omitted, a fresh UUID7 is generated. model: Optional model to use for this run, required if `model` was not set when creating the agent. instructions: Optional additional instructions to use for this run. deps: Optional dependencies to use for this run. model_settings: Optional settings to use for this model's request, or a callable that receives [`RunContext`][pydantic_ai.tools.RunContext] and returns settings. Callables are called before each model request, allowing dynamic per-step settings. usage_limits: Optional limits on model request count or token usage. cancellation_token: Token used to cancel this run from another task or thread. Single-use: mint a fresh token per run, as a reused (already-cancelled) token prevents the run from starting. usage: Optional usage to start with, useful for resuming a conversation or agents used in tools. metadata: Optional metadata to attach to this run. Accepts a dictionary or a callable taking [`RunContext`][pydantic_ai.tools.RunContext]; merged with the agent's configured metadata. retries: Override the agent-level retry budgets for this run. Pass an `int` to override both the tool-retry and output budgets, or an [`AgentRetries`][pydantic_ai.AgentRetries] dict to override just one (e.g. `retries={'tools': 3}`). See [`Agent.__init__`][pydantic_ai.agent.Agent.__init__] for semantics of the two enforcement paths. infer_name: Whether to try to infer the agent name from the call frame if it's not set. toolsets: Optional additional toolsets for this run. capabilities: Optional additional [capabilities](https://pydantic.dev/docs/ai/capabilities/overview/) for this run, merged with the agent's configured capabilities. spec: Optional agent spec to apply for this run. At run time, spec values are additive. Returns: The result of the run. rrxs rfr4rst"! ) rrrrr[ native_toolsrrrrrc ## [e7f)a Context manager to temporarily override agent configuration. This is particularly useful when testing. You can find an example of this [here](../testing.md#overriding-model-via-pytest-fixtures). Args: name: The name to use instead of the name passed to the agent constructor and agent run. deps: The dependencies to use instead of the dependencies passed to the agent run. model: The model to use instead of the model passed to the agent run. toolsets: The toolsets to use instead of the toolsets passed to the agent constructor and agent run. tools: The tools to use instead of the tools registered with the agent. native_tools: The native tools to use instead of the agent's configured native tools. instructions: The instructions to use instead of the instructions registered with the agent. metadata: The metadata to use instead of the metadata passed to the agent constructor. When set, any per-run `metadata` argument is ignored. model_settings: The model settings to use instead of the model settings passed to the agent constructor. When set, any per-run `model_settings` argument is ignored. retries: The retry budgets to use instead of the agent-level configuration. Pass an `int` to override both the tool-retry and output budgets, or an [`AgentRetries`][pydantic_ai.AgentRetries] dict to override just one (e.g. `retries={'tools': 3}`). When set, any per-run `retries` argument is ignored. spec: Optional agent spec providing defaults for override. r) rtrrrrr[rrrrrrs rfoverrideAbstractAgent.overridesP"!r rrrrrr*rrrrrc URc$UR[R"55 [ UUUUUUUUUU U U U S9 $)uBind this agent's configuration to a realtime `model`, returning an accessor for realtime operations. The returned [`AgentRealtime`][pydantic_ai.agent.AgentRealtime] carries the agent's realtime configuration so that opening a session with [`session()`][pydantic_ai.agent.AgentRealtime.session] reuses the same instructions, tools, capabilities, and run context without re-passing them. These parameters mirror [`iter`][pydantic_ai.agent.AbstractAgent.iter]. Parameters specific to the request-response graph — `output_type`, `retries`, `event_stream_handler`, `deferred_tool_results` — do not apply; structured output should be delegated to a normal [`Agent`][pydantic_ai.Agent] (see the realtime docs). Capabilities run `for_run` once when the session connects; their instructions, toolsets, and native tools are applied. Tool hooks (`prepare_tools` and `before`/`after`/`wrap`/ `on_error` for `tool_validate` and `tool_execute`) run for each tool call. Run hooks (`before_run`, `after_run`, `wrap_run`, `on_run_error`) run once around the session and event-stream hooks wrap the session iterator; graph, model-request, and output-stage hooks do not run. ```python from pydantic_ai import Agent from pydantic_ai.realtime import RealtimeTurnCompleteEvent from pydantic_ai.realtime.openai import OpenAIRealtimeModel agent = Agent(instructions='You are a helpful voice assistant.') @agent.tool_plain def get_weather(city: str) -> str: return f'Sunny in {city}' async def main(): model = OpenAIRealtimeModel('gpt-realtime') async with agent.realtime(model).session() as session: await session.send_audio(b'...') async for event in session: if isinstance(event, RealtimeTurnCompleteEvent): break # keep listening in a real call; we stop after one reply ``` Args: model: The realtime model to connect to. deps: Dependencies passed to tool functions. model_settings: Optional realtime settings overriding the model's defaults for the session. instructions: Additional instructions for the session, combined with the agent's instructions. Dynamic instruction functions (`@agent.instructions`) are evaluated once at connect time (there is no per-request rebuild in a realtime session). toolsets: Optional additional toolsets for the session, on top of the agent's. capabilities: Optional additional capabilities for the session. Their `for_run`, setup contributions, and tool-lifecycle hooks apply; run hooks fire once around the session and event-stream hooks wrap the iterator; model-request, graph, and output hooks are not invoked. usage: Optional [`RunUsage`][pydantic_ai.usage.RunUsage] to accumulate token usage into; exposed as `session.usage`. A fresh one is used when omitted. usage_limits: Optional [`UsageLimits`][pydantic_ai.usage.UsageLimits]. Request, token, and tool-call limits are enforced as usage accrues; a breach raises [`UsageLimitExceeded`][pydantic_ai.exceptions.UsageLimitExceeded] from the session's event iterator, matching how `run` / `iter` surface a usage limit. metadata: Optional metadata set on the [`RunContext`][pydantic_ai.tools.RunContext] available to tools and capabilities, and on the realtime session telemetry span. conversation_id: Optional conversation id, set on the run context and the telemetry span so a realtime session can be correlated with other runs. Session-built messages are stamped with it as well, allowing a later standard run to resume the same conversation; seeded messages are left unchanged. run_id: Optional ID for this realtime session, which is one long-lived run covering every exchange. Never inherited from `message_history`; passing an empty or previously used ID raises `UserError`. If omitted, a fresh UUID7 is generated and stamped on session-built messages, while seeded messages are left unchanged. message_history: Prior conversation to seed the session with. Replayable text, transcripts, thinking, tool rounds, images, and supported retained user audio are projected to the provider's initial conversation items; unrepresentable content raises `UserError`. The history is included in [`session.all_messages()`][pydantic_ai.realtime.RealtimeSession.all_messages] (but not `new_messages()`). Hand off from a prior session or a standard [`Agent.run`][pydantic_ai.agent.AbstractAgent.run] by passing its messages here. _agent_model_deps_model_settingsr# _toolsets _capabilities_usage _usage_limits _metadata_conversation_id_run_id_message_history)rr1r2r3 AgentRealtime) rtrrrrrrr*rrrrrs rfrealtimeAbstractAgent.realtimesZt 99    W113 4*&&&,,  reF) rrrrrr*rrrrr run_lifecyclec # [e7f)uResolve the agent configuration shared by realtime sessions and WebRTC signaling. With `run_lifecycle`, the run-lifecycle hooks are dispatched around the resolved configuration so they wrap the toolset — and the session the caller opens inside them — exactly as `iter` does. Only `_open_realtime_session` asks for that: signaling only reads back the instructions and tools a session would advertise, and is not itself a run. r)rtrrrrrrr*rrrrrrs rf_resolve_realtime_session'AbstractAgent._resolve_realtime_sessions 2"!rtranscript_onlyrdrrrrrr*rrrrraudio_retentionhandle_barge_inretain_images_every_nretain_images_maxprovider_sessionc# [e7f)aWorker behind [`AgentRealtime.session`][pydantic_ai.agent.AgentRealtime.session]. Implementations open the realtime session; not all agent implementations support realtime sessions. Users go through [`realtime()`][pydantic_ai.agent.AbstractAgent.realtime]. r)rtrrrrrrr*rrrrrrrrrrs rf_open_realtime_session$AbstractAgent._open_realtime_session2s 6"!rcNURbS5eUbUR=n(azURR5Hup4X@LdM X0l g URUR:wa0URR5Hup4X@LdM X0l g gggg)zjInfer the agent name from the call frame. RunUsage should be `self._infer_name(inspect.currentframe())`. NzName already set)rraf_localsitems f_globals)rtfunction_frame parent_frameritems rfr1AbstractAgent._infer_namePs yy 4"44  %-444|4"."7"7"="="?JD|$( #@ ((L,B,BB&2&<&<&B&B&D <(,I"'EC 5 &rec#t# [R"U5 Sv SSS5 g!,(df  g=f7f)aSet the parallel execution mode during the context. Args: mode: The execution mode for tool calls: - 'parallel': Run tool calls in parallel, yielding events as they complete (default). - 'sequential': Run tool calls one at a time in order. - 'parallel_ordered_events': Run tool calls in parallel, but events are emitted in order, after all calls complete. N)r<parallel_execution_moders rf!parallel_tool_call_execution_mode/AbstractAgent.parallel_tool_call_execution_modecs# 0 0 6 7 6 68' 8 58c#t# [R"U5 Sv SSS5 g!,(df  g=f7f)aDUse a custom executor for running sync functions in threads during the context. By default, sync tool functions and other sync callbacks are run in threads using [`anyio.to_thread.run_sync`][anyio.to_thread.run_sync], which creates ephemeral threads. In long-running servers (e.g. FastAPI), this can lead to thread accumulation under sustained load. This context manager lets you provide a bounded [`ThreadPoolExecutor`][concurrent.futures.ThreadPoolExecutor] (or any [`Executor`][concurrent.futures.Executor]) to control thread lifecycle: ```python {test="skip" lint="skip"} from concurrent.futures import ThreadPoolExecutor from contextlib import asynccontextmanager from pydantic_ai import Agent @asynccontextmanager async def lifespan(app): executor = ThreadPoolExecutor(max_workers=16) with Agent.using_thread_executor(executor): yield executor.shutdown(wait=True) ``` For per-agent configuration, use the [`UseThreadExecutor`][pydantic_ai.capabilities.UseThreadExecutor] capability instead. Args: executor: The executor to use for running sync functions. N)r$using_thread_executor)executors rfr#AbstractAgent.using_thread_executorqs$B ) )( 3 4 3 3rc#t# [R"U5 Sv SSS5 g!,(df  g=f7f)aUse a custom async sleep function for agent-graph delays during the context. By default the agent graph uses `asyncio.sleep` when it needs to wait during a run (e.g. between polls of a suspended/background model response). Durable execution frameworks (Temporal, Prefect, DBOS, ...) register their own durable sleep here so delays survive workflow replays and don't waste activity time. N)r"set_agent_graph_sleep) sleep_funcs rf using_sleepAbstractAgent.using_sleeps# / / ; < ; ;rc6[U[R5$)zCheck if the node is a `ModelRequestNode`, narrowing the type if it is. This method preserves the generic parameters while narrowing the type, unlike a direct call to `isinstance`. )rr"ModelRequestNoderGs rfr'#AbstractAgent.is_model_request_nodes$ = =>>rec6[U[R5$)zCheck if the node is a `CallToolsNode`, narrowing the type if it is. This method preserves the generic parameters while narrowing the type, unlike a direct call to `isinstance`. )rr" CallToolsNoderGs rfr( AbstractAgent.is_call_tools_nodes$ : :;;rec6[U[R5$)zCheck if the node is a `UserPromptNode`, narrowing the type if it is. This method preserves the generic parameters while narrowing the type, unlike a direct call to `isinstance`. )rr"rcrGs rfis_user_prompt_node!AbstractAgent.is_user_prompt_nodes$ ; ;<AbstractAsyncContextManager[AgentRun[AgentDepsT, OutputDataT]])(r rrrrrrrrrrrrrrrrr=rrrrrrr*rrrrrrrrrrrrrrzAAbstractAsyncContextManager[AgentRun[AgentDepsT, RunOutputDataT]])(r rrrrrrrrrrrrrrrrr=rrrrrrr*rrrrrrrrrrrrrrz)AsyncGenerator[AgentRun[AgentDepsT, Any]])rzstr | _utils.UnsetrzAgentDepsT | _utils.Unsetrz9models.Model | models.KnownModelName | str | _utils.Unsetrz4Sequence[AbstractToolset[AgentDepsT]] | _utils.Unsetr[zKSequence[Tool[AgentDepsT] | ToolFuncEither[AgentDepsT, ...]] | _utils.Unsetrz4Sequence[AgentNativeTool[AgentDepsT]] | _utils.Unsetrz:_instructions.AgentInstructions[AgentDepsT] | _utils.Unsetrz(AgentMetadata[AgentDepsT] | _utils.Unsetrz-AgentModelSettings[AgentDepsT] | _utils.Unsetrz!int | AgentRetries | _utils.UnsetrrrGenerator[None])r,RealtimeModel | KnownRealtimeModelName | strrr=rRealtimeModelSettings | Nonerrrrrrr*rrrrrrrrrrrrzAgentRealtime[AgentDepsT])rrrr=rrrrrrrrr*rrrrrrrrrrrrrrz6AsyncGenerator[_RealtimeSessionResolution[AgentDepsT]])$rrrr=rrrrrrrrr*rrrrrrrrrrrrrGrrrrZr int | NonerRealtimeProviderSession | NonerAsyncGenerator[RealtimeSession])rzFrameType | Nonerr)parallel)rz"tool_manager.ParallelExecutionModerr)rr rr)rz _agent_graph.AgentGraphSleepFuncrr)r99_agent_graph.AgentNode[T, S] | End[result.FinalResult[S]]rz+TypeIs[_agent_graph.ModelRequestNode[T, S]])r9rrz(TypeIs[_agent_graph.CallToolsNode[T, S]])r9rrz)TypeIs[_agent_graph.UserPromptNode[T, S]])r9rrz"TypeIs[End[result.FinalResult[S]]])rz&AbstractAgent[AgentDepsT, OutputDataT])rrrz bool | None)Nz pydantic-aiNNNN)rtrrr=rstrrrrrrrrrrr)0r^r_r`rarbrrrrsetterrrrrrrrrrrr!r;rBrrqryr4rr$UNSETrrrrr1 staticmethodrrrr'r(rrrrrrrdr]rerfrrZsc """" [["""""""""""""""" CGCG?C(,/3A  A  = &- *B,EI*!CG<@&*!CGDH@D267;(,59-1AEFJEI26-*A* * A * : *$**A*B**>*0*5*&* 3!*"+#*$%*&?'*(D)**C+*,0-*. %/**2EI- DH<@&*!CGDH@D267;(,59-1AEFJEI26--A-0 - A - : -$--A-B-->-0-5-&- 3!-"+#-$%-&?'-(D)-*C+-,0--. (/--6EIN :>CG<@&*!CGDH@D267;(,59-1AEFJEI26-N AN 7 N A N : N $N N AN BN N >N 0N 5N &N 3!N "+#N $%N &?'N (D)N *C+N ,0-N . /N `EI*!CG<@&*!CGDH@D267;(,59-1AEFJEI26-*A* * A * : *$**A*B**>*0*5*&* 3!*"+#*$%*&?'*(D)**C+*,0-*. %/**2EI- DH<@&*!CGDH@D267;(,59-1AEFJEI26--A-0 - A - : -$--A-B-->-0-5-&- 3!-"+#-$%-&?'-(D)-*C+-,0--. (/--6EIj :>CG<@&*!CGDH@D267;(,59-1AEFJEI26-j Aj 7 j A j : j $j j Aj Bj j >j 0j 5j &j 3!j "+#j $%j &?'j (D)j *C+j ,0-j . /j XEI]!CG<@&*!CGDH@D267;(,59-1AEFJEI26-]A] ] A ] : ]$]]A]B]]>]0]5]&] 3!]"+#]$%]&?'](D)]*C+],0-]. X/]]2EI` DH<@&*!CGDH@D267;(,59-1AEFJEI26-`A`0 ` A ` : `$``A`B``>`0`5`&` 3!`"+#`$%`&?'`(D)`*C+`,0-`. [/``2EI}b:>CG<@&*!CGDH@D267;(,59-1AEFJEI26-}bA}b7 }b A }b : }b$}b}bA}bB}b}b>}b0}b5}b&}b 3!}b"+#}b$%}b&?'}b(D)}b*C+}b,0-}b. C/}b}b~EID!CG<@&*!CG@D267;(,59-1AEFJEI26+DAD D A D : D$DDADD>D0D5D&D3D +!D"#D$?%D&D'D(C)D*0+D, ?-DD0EIG DH<@&*!CG@D267;(,59-1AEFJEI26+GAG0 G A G : G$GGAGG>G0G5G&G3G +!G"#G$?%G&D'G(C)G*0+G, B-GG4EIy :>CG<@&*!CG@D267;(,59-1AEFJEI26+y Ay 7 y A y : y $y y Ay y >y 0y 5y &y 3y +!y "#y $?%y &D'y (C)y *0+y , 7-y vEIG!CG<@&*!CGDH@D267;(,59-1AEEI26+GAG G A G : G$GGAGBGG>G0G5G&G 3!G"+#G$%G&?'G(C)G*0+G, B-GG0EIJ DH<@&*!CGDH@D267;(,59-1AEEI26+JAJ0 J A J : J$JJAJBJJ>J0J5J&J 3!J"+#J$%J&?'J(C)J*0+J, E-JJ4EI~2:>CG<@&*!CGDH@D267;(,59-1AEEI26+~2A~27 ~2 A ~2 : ~2$~2~2A~2B~2~2>~20~25~2&~2 3!~2"+#~2$%~2&?'~2(C)~2*0+~2, :-~2@EIM!CG<@&*!CGDH@D267;(,59-1AEEI26+MAM M A M : M$MMAMBMM>M0M5M&M 3!M"+#M$%M&?'M(C)M*0+M, H-MM0EIP DH<@&*!CGDH@D267;(,59-1AEEI26+PAP0 P A P : P$PPAPBPP>P0P5P&P 3!P"+#P$%P&?'P(C)P*0+P, K-PP0EIy:>CG<@&*!CGDH@D267;(,59-1AEEI26+yAy7 y A y : y$yyAyByy>y0y5y&y 3!y"+#y$%y&?'y(C)y*0+y, 3-yyv$*<<*0,,KQ<C!C!C C  CC!) rrrrr#rrrrrrrr)rzAbstractAgent[AgentDepsT, Any]rrrr=rrr#rrrrrrrrrrrrrrrrrrr)rrrrO)rrrrI) rrGrrrrZrrrrrr) r^r_r`rarbrvrrrrrdr]rerfrrOs3!8&PQU)V+< %%&(+;??(? ? # ? & ?9? )??rer) __future__r _annotationsrr2abcrrcollections.abcrrrr r r r concurrent.futuresr contextlibrrr dataclassesrtypesrrtypingrrrrrrranyio.streams.memoryrpydanticrtyping_extensionsrrrrpydantic_graphr r"r#r$r%r&rr'r(r)r*r_cancelr+r,r- _json_schemar._outputr/rr0r1r\r2r3r4r5r6r!r7r8r9settingsr:templater;r<r[r=r>r?r@rArBrrCpydantic_ai.agent.specrDpydantic_ai.capabilitiesrEpydantic_ai.models.instrumentedrFpydantic_ai.realtimerGrHrIrJrKrLrMrNrOrPrQrNoneTyperRrTrcrVdictr AgentMetadataAgentInstructions InstructionsAgentModelSettingsrXrhrrjrrrrrr]rerfr=s2#(WW!*II : >>   IH%,*%,@@??$"&'0;G    CL CL :)*d ( HI9UY?Z!Iz"* HI/1#il S#X:j+A*BDcN*R!SS !33c 2"Xz*/E.F .U%VV\9E.%-.@.E-F R`alRmHn-n$o ohl6 K- (B(BEXYdEe(efl6^