"jdSSKJr SSKrSSKrSSKJrJrJrJ r J r SSK J r SSK J r SSKJrJrJrJrJrJr SSKJrJr SSKJrJr SS KJrJr SS KJrJ r J!r!J"r"J#r#J$r$J%r%J&r& SS K'J(r( S S K)J*r*J+r+J,r,J-r.J/r0 S SK1J2r2J3r3J4r4 S SK5J6r6 S SK7J8r8 S SK9J:r: S SK;Jr> \(a S SK7J?r? S SK@JArA "SS\\\<5rBSrCS#SjrDS$SjrE\R"SS9"SS\\>\<455rG\R"SS \\<55rH\R"SS9"S!S"\\<55rIg)%) annotationsN) AsyncIterator AwaitableCallableMappingSequence)deepcopy)datetime) TYPE_CHECKINGAnyGenericLiteralcastoverload)model_serializermodel_validator)SerializationInfoSerializerFunctionWrapHandler) NotRequired TypedDict)BaseNodeEnd EndMarker ErrorMarkerGraphRunGraphRunContextGraphTaskRequestJoinItem)NodeStep) _agent_graph_utils exceptionsmessagesusage)EnqueueContentPendingMessagePendingMessagePriority)current_otel_traceparent) CustomEventT)drain_pending_messages_at_end) OutputDataT) AgentDepsT) RunContext) FinalResultcp\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S \S 'S \S'S\S'S\S'Srg)_AgentRunResultData$zNotRequired[OutputDataT]outputlist[_messages.ModelMessage]r$zNotRequired[int]new_message_indexzNotRequired[str | None]output_tool_namezNotRequired[_usage.RunUsage]r%zNotRequired[str]run_idconversation_idz"NotRequired[dict[str, Any] | None]metadata traceparentN)__name__ __module__ __qualname____firstlineno____annotations____static_attributes__r;L/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/run.pyr1r1$s8 $$**''-- '' %%00((rBr1)r%r7r8r9c[U[5(dU$[U[5(a:[SU5nUR 5VVs0sHupEXA;ULdMXE_M snn$[U[ 5(aP[U[ [45(d5[SU5n[U5VVs/sHupeXa;ULdMUPM snn$U$s snnfs snnf)uPApply one key's nested `include`/`exclude` spec to the value itself. Filters the container rather than re-serializing it, so the value stays whatever the outer schema expects. That bounds what can be applied: a plain set of keys or indices, against a mapping or a sequence — `exclude={'metadata': {'api_key'}}` and `exclude={'messages': {0}}`, the forms a caller reaches for to redact an entry or drop a message. A deeper spec, or one aimed at a key whose value is neither (`usage`), would need that value re-serialized against a sub-schema, so it is left alone; see `_filter_serialized`. Mapping[Any, Any]z Sequence[Any]) isinstancesetrritemsrstrbytes enumerate)valuespeckeeprHkeyitemindexs rC_filtered_valuerR4s dC  %!!(%0+0;;=R=icS[T[#\  .2ZZ\P\zsS=O  \PDzH%(89 $(( !"5t<BBDMC / x S E: O#M ]Ps" D:D:3!EE5 EEF)reprc\rSrSr%SrS\S'\R"SSSS9rS\S '\R"SSSS9r S \S '\R"SSSS9r S \S '\ S3Sj5r \ S4Sj5r SS.S5Sjjr \ S6Sj5r\ S7Sj5r\ S8Sj5rS9SjrSS.S:SjjrS9SjrS;SjrSSjrS?SjrS@S jrSAS!jrSBS"jrSCS#jrSDS$jrSES%jrSBS&jr \ SFS'j5r!\ SGS(j5r"\ S4S)j5r#\ S4S*j5r$\ SHS+j5r%SIS,jr&S-S..SJS/jjr'SKS0jr(S4S1jr)S2r*g)LAgentRunlaA stateful, async-iterable run of an [`Agent`][pydantic_ai.agent.Agent]. You generally obtain an `AgentRun` instance by calling `async with my_agent.iter(...) as agent_run:`. Once you have an instance, you can use it to iterate through the run's nodes as they execute. When an [`End`][pydantic_graph.basenode.End] is reached, the run finishes and [`result`][pydantic_ai.agent.AgentRun.result] becomes available. Example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-5.2') async def main(): nodes = [] # Iterate through the run, recording each node along the way: 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. ``` You can also manually drive the iteration using the [`next`][pydantic_ai.agent.AgentRun.next] method for more granular control. znGraphRun[_agent_graph.GraphAgentState, _agent_graph.GraphAgentDeps[AgentDepsT, Any], FinalResult[OutputDataT]] _graph_runNF)defaultr]init"AgentRunResult[OutputDataT] | None_result_overridezBaseException | None _node_errorzV_agent_graph.AgentNode[AgentDepsT, OutputDataT] | End[FinalResult[OutputDataT]] | None_last_yielded_nodecgNr;selfrequireds rC _traceparentAgentRun._traceparentGJrBcgrir;rks rCrmrn#&rBTrlc|URRSS9nUc [5nUcU(a [S5eU$)NFrs&No span was created for this agent run)rarmr)AttributeError)rkrlr:s rCrmrnsCoo22E2B  34K  8 !IJ JrBc[[R[R[[ 44"UR RUR RS9$)z%The current context of the agent run.)statedeps) rr!GraphAgentStateGraphAgentDepsr-r rarxryrqs rCctx AgentRun.ctxsL|;;\=X=XYcehYh=iij//''doo.B.B  rBcURRn[U[5(a UReUR U5$)zThe next node that will be run in the agent graph. This is the next node that will be used during async iteration, or if a node is not passed to `self.next(...)`. )ra next_taskrFrerror _task_to_node)rktasks rC next_nodeAgentRun.next_nodes;(( dK ( (** !!$''rBc ,URb UR$URRnUcg[URURURR URR RURSS95$)zThe final result of the run if it has ended, otherwise `None`. Once the run returns an [`End`][pydantic_graph.basenode.End] node, `result` is populated with an [`AgentRunResult`][pydantic_ai.agent.AgentRunResult]. NFrs) rerar3AgentRunResult tool_namerxryr5rm)rkgraph_run_outputs rCresultAgentRun.results  ,(( (??11  #  # #  & & OO ! ! OO 2 2   u  -   rBcBURRR$)zPReturn all messages for the run so far. Messages from older runs are included. )r|rxmessage_historyrqs rC all_messagesAgentRun.all_messagess xx~~---rBoutput_tool_return_contentc\[RRUR55$)zReturn all messages from [`all_messages`][pydantic_ai.agent.AgentRun.all_messages] as JSON bytes. Returns: JSON bytes representing the messages.  _messagesModelMessagesTypeAdapter dump_jsonrrkrs rCall_messages_jsonAgentRun.all_messages_json$ 11;;D>D'g 8D !YYx00 #' ) #1  #&  sHB1D/3D4>D$))    --i88$$rBc[U[5(aEURRn[U[5=(a UR UR L$UR5UL$)aUWhether the graph runner's own state already records `result` as the step's outcome. False whenever the two have diverged, whatever the cause: the graph is still pending on the node a hook short-circuited past, or holds an `ErrorMarker` for an error a hook handled, or advanced to the handler's node while the hook returned something else. )rFrrarrrLrWr)rkrrs rC_graph_reflectsAgentRun._graph_reflectsysS fc " "??,,DdI.L4::3L L'')V33rBc# URU5/nURRU5IShvN nUR U5$N![a Nf=f7f)z hhmm++(((@@ ""$++KwGGG AHs$BB;B7.B;2B93B;9B;cT# URXR5IShvN $N7f)a Manually drive the agent run by passing in the node you want to run next. This lets you inspect or mutate the node before continuing execution, or skip certain nodes under dynamic conditions. The agent run should be stopped when you return an [`End`][pydantic_graph.basenode.End] node. Example: ```python from pydantic_ai import Agent from pydantic_graph import End agent = Agent('openai:gpt-5.2') async def main(): async with agent.iter('What is the capital of France?') as agent_run: next_node = agent_run.next_node # start with the first node nodes = [next_node] while not isinstance(next_node, End): next_node = await agent_run.next(next_node) nodes.append(next_node) # Once `next_node` is an End, we've finished: 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('Final result:', agent_run.result.output) #> Final result: The capital of France is Paris. ``` Args: node: The node to run next in the graph. Returns: The next node returned by the graph logic, or an [`End`][pydantic_graph.basenode.End] node if the run has completed. N)r_stream_and_advancers rCr AgentRun.nexts%X..t5M5MNNNNs (&(cP# URRRR(d/URRRR(a([ R "XR5IShvN URU5IShvN $NN7f)a[Execute a single graph step, streaming the node first if capabilities need its events. A capability that overrides `wrap_run_event_stream` only sees events if the node is streamed, so streaming is enabled for it here the same way `agent.run()` enables it. `node.stream()` applies the capability chain itself, so draining it is all that's needed. N)r|ryrhas_wrap_run_event_stream has_on_eventr!drain_node_event_streamrrs rCrAgentRun._stream_and_advance,si 88== ( ( B BdhhmmFcFcFpFp66tXXF F F((... G.s$BB&B"B&B$B&$B&cBURRR$)zZGet usage statistics for the run so far, including token usage, model requests, and so on.)rarxr%rqs rCr%AgentRun.usage:s$$***rBcBURRR$z7Metadata associated with this agent run, if configured.)rarxr9rqs rCr9AgentRun.metadata?s$$---rBcBURRR$z(The unique identifier for the agent run.)rarxr7rqs rCr7AgentRun.run_idDs$$+++rBcBURRR$z?The unique identifier for the conversation this run belongs to.)rarxr8rqs rCr8AgentRun.conversation_idIs$$444rBcBURRR$)zInternal: live view of the queue mutated by `enqueue` and drained by the internal `PendingMessageDrainCapability`. Exposed for inspection / debugging; use [`enqueue`][pydantic_ai.run.AgentRun.enqueue] to add messages. )rarxpending_messagesrqs rCrAgentRun.pending_messagesNs $$555rBc# URb[R"S5e[U[R 5(a[R"S5eUR RRRU5 U$7f)aEmit a [`CustomEvent`][pydantic_ai.messages.CustomEvent] into this run's event stream. Lets code driving [`Agent.iter`][pydantic_ai.agent.AbstractAgent.iter] inject application-defined events (e.g. from an external harness or event bus) into the stream, alongside events emitted from tools via [`RunContext.emit`][pydantic_ai.tools.RunContext.emit]. The event surfaces on the next pull from the run's node stream. Designed to be called from the same event loop driving `agent.iter()`. If you're forwarding events from a different thread, submit the coroutine to the agent's loop (e.g. `asyncio.run_coroutine_threadsafe(agent_run.emit(event), loop)`). Args: event: The [`CustomEvent`][pydantic_ai.messages.CustomEvent] to emit. Returns: The event as emitted. Raises: UserError: If the run has already ended (no stream remains to deliver the event), or if passed a [`CapabilityEvent`][pydantic_ai.messages.CapabilityEvent]: those belong to capabilities, and code driving the run is application code. zV`emit` cannot be called after the run has ended: nothing remains to deliver the event.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.) rr# UserErrorrFrCapabilityEventrarxevent_stream_bufferappend)rkevents rCemit AgentRun.emitVsy. ;; "&&h  eY66 7 7&&4  1188? sB B asap)priorityc[R"USU06nUcgURRRR U5 UR $)uZEnqueue content to be injected into the conversation. Safe to call directly from synchronous or asynchronous code, including a callback running in another thread. 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). `'when_idle'` — only when the agent would otherwise end, after `'asap'` messages. 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 has ended, since there'd be nowhere to deliver the message. rN)r' from_contentrarxrr enqueue_id)rkrcontentpendings rCenqueueAgentRun.enqueuezsLD!--wJJ ? ..55g>!!!rBc`URRRR5 g)uCancel the whole agent run. The run stops what it is doing — the in-flight model request is torn down, in-flight tool tasks are cancelled and drained, a suspended server-side job is best-effort cancelled — and the code driving the run sees `asyncio.CancelledError`. When the `agent.iter()` context exits, this becomes [`RunCancelled`][pydantic_ai.exceptions.RunCancelled] (including for `agent.run()`, which wraps `iter()`). Everything that completed before the cancellation took effect is preserved in message history. [`RunCancelled.all_messages()`][pydantic_ai.exceptions.RunCancelled.all_messages] returns a complete snapshot that can be passed to a new run as `message_history` to resume the conversation. Cancellation is terminal: capability hooks (`wrap_run`, `wrap_node_run`, `on_run_error`) may observe it and clean up, but cannot recover the run into a successful result. Unlike [`StreamedRunResult.cancel()`][pydantic_ai.result.StreamedRunResult.cancel], which only stops the current model response and lets the run continue, this ends the run itself. Safe to call from another task or thread (e.g. a TUI's key handler while the run is awaited elsewhere). Idempotent; a no-op once the run has finished — where "finished" means the `agent.iter()`/`agent.run()` context has exited. A `cancel()` issued inside the context after the run has already produced its result (e.g. after iterating to `End`) is still honored and surfaces as `RunCancelled` on exit, so that a hook running at context exit (like `after_run`) can still cancel the run; only after the context has exited is `cancel()` a true no-op. Externally cancelling the task running the agent (`asyncio.Task.cancel()`) remains supported and keeps raising `asyncio.CancelledError` instead; when both happen, the external cancellation wins. N)r|ryrcancelrqs rCrAgentRun.cancels:  ""))+rBcURRnUcSO[UR5nS[U5RSUSUR S3$)Nz)rar3r]rr<r%)rkr result_reprs rC__repr__AgentRun.__repr__sP''.4n*$v}}BU 4:&&'x }GDJJr?__doc__r@ dataclassesfieldrerfrgrrmpropertyr|rrrrrrrrrrrrrrrrrrr%r9r7r8rrr rrrAr;rBrCr_r_ls@DRrBr_c8\rSrSr%SrS\S'\R"SSSS9rS\S '\R"SS\ RS 9r S \S '\R"SSS S9r S\S'\R"SSSS9r S\S'\"SS9\S(Sj55r\"SS9S)Sj5r\S*Sj5r\S+Sj5rSS.S,SjjrS-SjrSS.S.SjjrSS.S/SjjrSS.S.SjjrSS.S/S jjr\S0S!j5r\S1S"j5r\S2S#j5r\S3S$j5r\S+S%j5r\S+S&j5r S'r!g)4riz!The final result of an agent run.r,r3FN)r]comparerbr_output_tool_name)r]r*default_factoryz_agent_graph.GraphAgentState_staterint_new_message_index_traceparent_valuebefore)modec[U[5(dU$[SU5n[URS5=n[5(a[SU5nURSS5URS5URS5S.nSU;aUSUS '[HnXd;dM XFXV'M 0UEUR 5VVs0sHupgUR S 5(aMXg_M! snnEn0nS U;aUS US'[HnXb;dM X&X'M URS 5UURS S5URS 5S.n SU;aUSU S'U $s snnf)zAccept the public serialized shape, and the private one older versions produced. Returns the private field names the dataclass schema validates, so `messages`, `usage`, `run_id`, `conversation_id` and `metadata` land back on `_state`. dict[str, Any]r-r/rr+r0)r5r6r:rr$_r6r5r:)r+r-r/r0r3)rFrVrget _STATE_KEYSrH startswith) clsrLrW legacy_staterxrestoredrOrP state_data validateds rC_validate_serialized#AgentRunResult._validate_serializedsx%&&L$e, dhhx&88l$ ? ?)<8E%)XX.BA%F$(HH-@$A#xx(<=(H !E)',->'?$"<$)JHM#hhgdjjl"flRUR`R`adRe939l"fgD%'  ,0,"B"&((="9 % t "&x.Ih %#gs E"(E"wrapc [SU"[URS955nURRUR UR URRURRURRURRURS.nSU;aUSUS'[S[XB55$)Nr4)r3)r$r5r6r%r7r8r9r:r3_AgentRunResultData[Any]) rrr3r-rr/r+r%r7r8r9r0r\)rkrrX serializedrWs rC _serializeAgentRunResult._serializes*GN$++4V,WX  33!%!8!8 $ 6 6[[&&kk((#{{:: ,,22 *  z !(1DN.0B40NOOrBcgrir;rjs rCrmAgentRunResult._traceparentrorBcgrir;rqs rCrmrGrrrBTrscXURcU(a [S5eUR$)Nru)r0rvrjs rCrmrG!s(  " " *x !IJ J&&&rBcUR(d [S5eURRnUSn[ UR 5HqupE[ U[R5(dM&URUR:XdMB[U5n[U5nXR Ul XvS'Us $ [SUR<S35e)zSet return content for the output tool. Useful if you want to continue the conversation and want to set the response to the output tool call. zDCannot set output tool return content when the return type is `str`.z"No tool call found with tool name .)r+ ValueErrorr-rrKpartsrFrToolReturnPartrlistr r  LookupError)rkreturn_contentr$ last_messageidxpartcopied_messages copied_lasts rC_set_output_tool_return&AgentRunResult._set_output_tool_return&s %%cd d;;..| "<#5#56IC$ 8 899dnnPTPfPf>f"&x.&|4 1?!!#&.&1#&&7>t?U?U>XXYZ[[rBrcVUbURU5$URR$)aReturn the history of _messages. Args: output_tool_return_content: The return content of the tool call to set in the last message. This provides a convenient way to modify the content of the output tool call if you want to continue the conversation and want to set the response to the output tool call. If `None`, the last message will not be modified. Returns: List of messages. )rXr-rrs rCrAgentRunResult.all_messages;s, & 1//0JK K;;.. .rBcZ[RRURUS95$)aReturn all messages from [`all_messages`][pydantic_ai.agent.AgentRunResult.all_messages] as JSON bytes. Args: output_tool_return_content: The return content of the tool call to set in the last message. This provides a convenient way to modify the content of the output tool call if you want to continue the conversation and want to set the response to the output tool call. If `None`, the last message will not be modified. Returns: JSON bytes representing the messages. rrrs rCr AgentRunResult.all_messages_jsonL/11;;   9S  T  rBc:URUS9URS$)aReturn the messages produced during this run. Messages provided via `message_history` and messages from older runs are excluded. Args: output_tool_return_content: The return content of the tool call to set in the last message. This provides a convenient way to modify the content of the output tool call if you want to continue the conversation and want to set the response to the output tool call. If `None`, the last message will not be modified. Returns: List of new messages. rN)rr/rs rCrAgentRunResult.new_messages\s(  r?r%r@r&r'r+r!rzr-r/r0r classmethodr>rrDrrmrXrrrrr(rgr%rlr9r7r8rAr;rBrCrrs+ -$/$5$55%Y]$^z^+6+<+< E<3O3O,F (*//UESTUU%0%6%6E5Z^%_ _(#+$+Z6"P#P0JJ &&/3' \*HL/"MQ HLs MQ EE!!''$$""++rBrcX\rSrSr%SrS\S'S\S'SrS\S '\Rr S r g ) AgentRunResultEventizYAn event indicating the agent run ended and containing the final result of the agent run.zAgentRunResult[OutputDataT]rzdataclasses.KW_ONLYr5agent_run_resultzLiteral['agent_run_result'] event_kindr;N) r<r=r>r?r%r@rxr"dataclasses_no_defaults_reprrrAr;rBrCrvrvs-c '' .@J+@922HrBrv)rLr rMr rNrrr )rWzMapping[str, Any]rXrrr4)J __future__r _annotationsrr&collections.abcrrrrrcopyr r typingr r r rrrpydanticrrpydantic_core.core_schemarrtyping_extensionsrrpydantic_graphrrrrrrrrpydantic_graph.steprr!r"r#r$rr%_usage_enqueuer&r'r(_instrumentationr) _run_contextr*capabilities._pending_messagesr+r3r,toolsr-r.rr/r1r7rRr\ dataclassr_rrvr;rBrCrs2QQGG6V4www(ML6&I(# ))W[%9 )A \* F E"W Rwz;./W R#W Rt T+W[)T+T+n E" 3'+. 3# 3rB