"jgSSKJr SSKrSSKrSSKJrJr SSKJrJ r SSK J r SSK J r Jr SSKrSSKJr SS KJrJrJr \R*S :aSS KJr O\r\ (aSS KJrJrJrJr SS KJr Sr"SS\ 5r!"SS\ 5r""SS\ 5r#"SS\ 5r$"SS\ 5r%"SS\ 5r&"SS\ 5r'"SS\(5r)"SS \)5r*"S!S"\(5r+S#r,"S$S%\+5r-"S&S'\+5r."S(S)\+5r/"S*S+\+5r0"S,S-\+5r1"S.S/\15r2"S0S1\+5r3"S2S3\35r4"S4S5\\5r5"S6S7\ 5r6"S8S9\ 5r7"S:S;\15r8"S<S=\95r:g)>) annotationsN)MappingSequence)datetimetimezone)parsedate_to_datetime) TYPE_CHECKINGAny) core_schema)CostCalculationFailedWarningCostNotFoundWarningPydanticAIDeprecationWarning) )ExceptionGroup) ModelMessage ModelResponseRetryPromptPartToolReturnPartRunUsage) ModelRetry CallDeferredApprovalRequiredSkipModelRequestSkipToolValidationSkipToolExecution UserErrorUndrainedPendingMessagesError AgentRunError RunCancelledSuspendedResponseExpiredUnexpectedModelBehaviorUsageLimitExceededConcurrencyLimitExceeded ModelAPIErrorModelHTTPErrorContentFilterErrorIncompleteToolCallMessageHistoryMutatedWarningr rrFallbackExceptionGroup ToolFailedcf^\rSrSr%SrS\S'S U4SjjrS SjrS Sjr\ S Sj5r S r U=r $)r9asException to raise to request a model retry. Can be raised from tool functions, output validators, and capability hooks (such as `after_model_request`, `after_tool_execute`, etc.) to send a retry prompt back to the model asking it to try again. For a terminal failure the model should see but not retry, raise [`ToolFailed`][pydantic_ai.exceptions.ToolFailed] instead. strmessagec0>Xl[TU] U5 gNr1super__init__selfr1 __class__s S/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/exceptions.pyr6ModelRetry.__init__G  !cl[XR5=(a URUR:H$r3 isinstancer9r1r8others r:__eq__ModelRetry.__eq__K#%0RU]]dll5RRr=cD[URUR45$r3hashr9r1r8s r:__hash__ModelRetry.__hash__NT^^T\\233r=c *[R"[R"[R"55[R"[R"S/55S.5n[R "SU[R "SUS9S9$)z@Pydantic core schema to allow `ModelRetry` to be (de)serialized. model-retryr1kindc[US5$Nr1)r)dcts r:9ModelRetry.__get_pydantic_core_schema__..[s 3y>2r=c URSS.$)NrNrOr1xs r:rTrU^ aiiGr= return_schema) serialization)r typed_dict_schematyped_dict_field str_schemaliteral_schema no_info_after_validator_function$plain_serializer_function_ser_schema)cls___schemas r:__get_pydantic_core_schema__'ModelRetry.__get_pydantic_core_schema__Qs|..&77 8N8N8PQ#44[5O5OQ^P_5`a   ;; 2 %JJG$  r=rWr1r0)rBr returnboolrkintrer rfr rkzcore_schema.CoreSchema __name__ __module__ __qualname____firstlineno____doc____annotations__r6rCrJ classmethodrh__static_attributes__ __classcell__r9s@r:rr9s6L-"S4  r=rcf^\rSrSr%SrS\S'S U4SjjrS SjrS Sjr\ S Sj5r S r U=r $)r-duException to raise to report a terminal tool failure to the model. Raise this when a tool call is done and has failed — a missing resource, an unsupported operation, a definitive upstream error — and you want the model to see the failure and adapt rather than try the same call again. Can be raised from tool functions, args validators, and tool validation/execution hooks. Like [`ModelRetry`][pydantic_ai.exceptions.ModelRetry], this produces a failed tool result the model sees; unlike `ModelRetry` it does not prepend retry/correction instructions and does not consume the tool's retry budget. Bound repeated failures with [`UsageLimits`][pydantic_ai.usage.UsageLimits] at the run level instead. r0r1c0>Xl[TU] U5 gr3r4r7s r:r6ToolFailed.__init__ur<r=cl[XR5=(a URUR:H$r3r?rAs r:rCToolFailed.__eq__yrEr=cD[URUR45$r3rGrIs r:rJToolFailed.__hash__|rLr=c ^[R"[R"[R"55[R"[R"S/55S.5n[R "U4SjU5n[R "U[R"[R"T5U/5[R"SUS9S9$)z@Pydantic core schema to allow `ToolFailed` to be (de)serialized. tool-failedrOc>T"US5$rR)rSrds r:rT9ToolFailed.__get_pydantic_core_schema__..sC N+r=c URSS.$)NrrOrWrXs r:rTrrZr=r[) json_schema python_schemar]) r r^r_r`rarbjson_or_python_schema union_schemais_instance_schemarc)rdrerfserialized_schemadeserialization_schemas` r:rh'ToolFailed.__get_pydantic_core_schema__s(99&77 8N8N8PQ#44[5O5OQ^P_5`a   "-!M!M + " 00.%22K4R4RSV4WYo3pq%JJG/  r=rWrj)rBobjectrkrlrmrorprzs@r:r-r-ds6 L5"S4  r=r-c>^\rSrSrSrSSU4SjjjrSSjrSrU=r$) raCException to raise when a tool call should be deferred. See [tools docs](../deferred-tools.md#deferred-tools) for more information. Args: metadata: Optional dictionary of metadata to attach to the deferred tool call. This metadata will be available in `DeferredToolRequests.metadata` keyed by `tool_call_id`. c.>Xl[TU] 5 gr3metadatar5r6r8rr9s r:r6CallDeferred.__init__  r=c4URUR44$r3r9rrIs r: __reduce__CallDeferred.__reduce__~~ ///r=rr3rdict[str, Any] | Nonerkztuple[type, tuple[Any, ...]] rqrrrsrtrur6rrxryrzs@r:rr00r=rc>^\rSrSrSrSSU4SjjjrSSjrSrU=r$) raeException to raise when a tool call requires human-in-the-loop approval. See [tools docs](../deferred-tools.md#human-in-the-loop-tool-approval) for more information. Args: metadata: Optional dictionary of metadata to attach to the deferred tool call. This metadata will be available in `DeferredToolRequests.metadata` keyed by `tool_call_id`. c.>Xl[TU] 5 gr3rrs r:r6ApprovalRequired.__init__rr=c4URUR44$r3rrIs r:rApprovalRequired.__reduce__rr=rr3rrrrzs@r:rrrr=rc<^\rSrSr%SrS\S'SU4SjjrSrU=r$)rajException to raise in before/wrap model request hooks to skip the model call. The provided response will be used instead of calling the model. Note: when raised in `before_model_request`, any message history modifications made by earlier capabilities in that hook will not be persisted to the agent's message history, since the request preparation is aborted. rresponsec.>Xl[TU] 5 gr3)rr5r6)r8rr9s r:r6SkipModelRequest.__init__rr=)r)rr rqrrrsrtrurvr6rxryrzs@r:rrsr=rc<^\rSrSr%SrS\S'SU4SjjrSrU=r$)rzException to raise in before/wrap tool validate hooks to skip validation. The provided args will be used as the validated arguments. dict[str, Any]validated_argsc.>Xl[TU] 5 gr3)rr5r6)r8rr9s r:r6SkipToolValidation.__init__s, r=)r)rrrrzs@r:rrs #"r=rc<^\rSrSr%SrS\S'SU4SjjrSrU=r$)rz~Exception to raise in before/wrap tool execute hooks to skip execution. The provided result will be used as the tool result. r resultc.>Xl[TU] 5 gr3)rr5r6)r8rr9s r:r6SkipToolExecution.__init__s  r=)r)rr rrzs@r:rrs Kr=rc>^\rSrSr%SrS\S'SU4SjjrSrU=r$)ruEError caused by a usage mistake by the application developer — You!r0r1c0>Xl[TU] U5 gr3r4r7s r:r6UserError.__init__r<r=rWrjrrzs@r:rrsO L%""r=rc\rSrSrSrSrg)r aError that used to be raised when an agent run ended with messages still queued via `enqueue`. A bare `async for node in agent_run` loop used to skip the node hooks, so `'when_idle'` messages and end-of-run redirects (which drain in `after_node_run`) were stranded. Bare iteration now advances through [`AgentRun.next()`][pydantic_ai.run.AgentRun.next] like every other way of driving a run, so pending messages always drain and this error is no longer raised. It is kept so existing `except` clauses keep working. rNrqrrrsrtrurxrr=r:r r sr=r cH^\rSrSr%SrS\S'SU4SjjrS SjrSrU=r $) r!z4Base class for errors occurring during an agent run.r0r1c0>Xl[TU] U5 gr3r4r7s r:r6AgentRunError.__init__r<r=cUR$r3rWrIs r:__str__AgentRunError.__str__s ||r=rWrjrkr0) rqrrrsrtrurvr6rrxryrzs@r:r!r!s> L"r=r!_pydantic_ai_run_cancelledc$^\rSrSrSrSSSSSSS.SU4SjjjrSSjrSS jr\SS j5r SS jr SS jr SS jr SSjr \SSj5r\SSj5r\SSj5r\SSj5r\S Sj5r\S Sj5rSrU=r$)!r"i uRaised when the agent run was cancelled by the application itself. Raised by [`AgentRun.cancel()`][pydantic_ai.run.AgentRun.cancel] and [`RunContext.cancel()`][pydantic_ai.tools.RunContext.cancel]. This is a normal, catchable application-level outcome: the run stopped because your own code asked it to. External cancellation of the task running the agent (`asyncio.Task.cancel()`, a timeout scope, workflow cancellation under durable execution) is infrastructure-level and keeps propagating as `asyncio.CancelledError` instead — it is never translated into this exception, and when both race, the external cancellation wins. (On Python 3.10, which lacks `Task.uncancel()`, the race cannot be disambiguated and a requested first-party cancellation wins instead.) Everything the run completed before the cancellation took effect — including the partial response of an interrupted stream and the results of tool calls that finished — is preserved in [`all_messages()`][pydantic_ai.exceptions.RunCancelled.all_messages]: pass it as `message_history` to a new run (with a new user prompt or not) to resume the conversation; any tool calls that never produced a result are automatically closed out with synthesized `outcome='interrupted'` returns before the history is sent to a model. Cancellation is terminal: capability hooks (`wrap_run`, `wrap_node_run`, `on_run_error`) may observe it and clean up, but cannot recover a cancelled run into a successful result. rrN)messagesnew_message_indexusagerrun_idconversation_idc>Uc SSKJn U"5n[U5UlX0lX@lXPlX`lXpl[T U])U5 g)Nr r) rrlist _messages_new_message_index_usage _metadata_run_id_conversation_idr5r6) r8r1rrrrrrrr9s r:r6RunCancelled.__init__$sG = 'JEh"3 ! / !r=cJURUR4UR4$r3)r9r1__dict__rIs r:rRunCancelled.__reduce__;s~~  ==r=c&[U[U5 gr3)setattr_RUN_CANCELLED_ATTR)r8excs r: _attach_toRunCancelled._attach_to>s($/r=cU/n[5nU(aUR5n[U5nXS;aM)URU5 [ X@5(aU$[ U[ S5n[ X`5(aU$URbURUR5 URbURUR5 U(aMg)uRecover run state from a cancellation-related exception. External cancellation of a plain `agent.run()` keeps its standard asyncio semantics. Catch it with `except asyncio.CancelledError as exc`, then call `RunCancelled.from_cancellation(exc)` to access the partial run state attached by Pydantic AI. This also works with the `TimeoutError` raised by `asyncio.timeout()` or `asyncio.wait_for()`, whose exception chain contains the original `CancelledError`. An external `CancelledError` must keep propagating for timeouts and task groups to tear down correctly, so re-raise it after capturing the state rather than returning from the handler; only a first-party `RunCancelled` is yours to consume. Passing a `RunCancelled` directly returns the same instance, providing uniform handling for first-party and external cancellation paths. Python 3.11+ preserves the exception instance across an `await task` boundary. Python 3.10 recreates the `CancelledError` there, but chains the original exception — and the attached run state — via `__context__`, which this method traverses; the chain is attached only to the first `await` of the cancelled task, so later awaits of the same task see an unchained exception. Use `capture_run_messages()` as the fallback when only message history is needed. N) setpopidaddr@getattrr __cause__append __context__)rdrpendingvisitedcurrent current_idattacheds r:from_cancellationRunCancelled.from_cancellationAs,%EkkmGGJ$ KK #'''w(;TBH(((  ,w001"".w223!g"r=cUR$)zReturn the complete resumable history of the cancelled run. This is a DETACHED snapshot of the run's message history at termination, ready to pass as `message_history` for a resumed run. Returns: List of messages. )rrIs r: all_messagesRunCancelled.all_messagesls~~r=cLSSKJn URUR55$)zReturn all messages from [`all_messages`][pydantic_ai.exceptions.RunCancelled.all_messages] as JSON bytes. Returns: JSON bytes representing the messages. r ModelMessagesTypeAdapter)rr dump_jsonrr8rs r:all_messages_jsonRunCancelled.all_messages_jsonw! 7'11$2C2C2EFFr=c4URURS$)zReturn the messages produced during the cancelled run. Messages provided via `message_history` and messages from older runs are excluded. Returns: List of new messages. N)rrrIs r: new_messagesRunCancelled.new_messagess~~d55788r=cLSSKJn URUR55$)zReturn new messages from [`new_messages`][pydantic_ai.exceptions.RunCancelled.new_messages] as JSON bytes. Returns: JSON bytes representing the new messages. r r)rrrrrs r:new_messages_jsonRunCancelled.new_messages_jsonrr=cSSKJn [UR55Hn[ X!5(dMUs $ [ S5e)zReturn the last response from the message history. Raises: ValueError: If the run was cancelled before receiving any model response. r )rz(No response found in the message history)rrreversedrr@ ValueError)r8rr1s r:rRunCancelled.responses= , 1 1 34G'115CDDr=c.URR$)zReturn the timestamp of the last response. Raises: ValueError: If the run was cancelled before receiving any model response. )r timestamprIs r:r RunCancelled.timestamps}}&&&r=cUR$)z&Return the usage of the cancelled run.)rrIs r:rRunCancelled.usages{{r=cUR$)z7Metadata associated with this agent run, if configured.)rrIs r:rRunCancelled.metadatas~~r=cUR$)zWThe unique identifier for the agent run, or `None` if it was cancelled before starting.)rrIs r:rRunCancelled.run_ids||r=cUR$)zPThe conversation identifier, or `None` if the run was cancelled before starting.)rrIs r:rRunCancelled.conversation_ids$$$r=)rrrrrr)r1r0rzSequence[ModelMessage]rrnrzRunUsage | Nonerrr str | Nonerr)rkz'tuple[type, tuple[str], dict[str, Any]])r BaseExceptionrkNone)rrrkzRunCancelled | None)rkzlist[ModelMessage])rkbytes)rkr)rkr)rkr)rkr)rkr)rqrrrsrtrur6rrrwrrrrrpropertyrr rrrrrxryrzs@r:r"r" s6,.!"!%*.!&*"") "  "  "(""$"".>0((T G9G E E''%%r=r"c\rSrSrSrSrg)r#iaRaised when resuming a suspended response whose server-side job is no longer available. Suspended/background jobs are only resumable within the provider's retention window (e.g. ~10 minutes for OpenAI background mode). Resuming a persisted suspended response after that window raises this instead of an opaque provider HTTP error; start a new run from the preceding messages to retry from scratch. rNrrr=r:r#r#sr=r#c4^\rSrSrSrSrSU4SjjrSrU=r$)r%iz?Error raised when a Model's usage exceeds the specified limits.zConsider raising the limit, or see the docs on usage limits for budget-aware patterns: https://pydantic.dev/docs/ai/core-concepts/agent/#usage-limitsc>URU;a URS5SUR3n[TU] U5 g)N.z. )_HINT removesuffixr5r6r7s r:r6UsageLimitExceeded.__init__s< ::W $ --c232djj\BG !r=rrj) rqrrrsrtrurr6rxryrzs@r:r%r%sI d ""r=r%c\rSrSrSrSrg)r&izAError raised when the concurrency queue depth exceeds max_queued.rNrrr=r:r&r&Kr=r&cb^\rSrSr%SrS\S'S\S'S S U4SjjjrS SjrSS jrS r U=r $)r$izLError caused by unexpected Model behavior, e.g. an unexpected response code.r0r1rbodyc>XlUcSUlO/[R"[R"U5SS9Ul[ TU]U5 g![ a X lN"f=f)N)indent)r1r#jsondumpsloadsrr5r6)r8r1r#r9s r:r6 UnexpectedModelBehavior.__init__sY <$(DI ! JJtzz$'7B  ! !  !s.AA%$A%cJURURUR44$r3)r9r1r#rIs r:r"UnexpectedModelBehavior.__reduce__s~~ dii888r=crUR(aURSUR3$UR$)Nz, body: r#r1rIs r:rUnexpectedModelBehavior.__str__s, 99ll^9TYYK8 8<< r=r.r3)r1r0r#rrr) rqrrrsrtrurvr6rrrxryrzs@r:r$r$s0V L1 1 " "9  r=r$c\rSrSrSrSrg)r)izARaised when content filtering is triggered by the model provider.rNrrr=r:r)r)r!r=r)cH^\rSrSr%SrS\S'SU4SjjrS SjrSrU=r $) r'iz/Raised when a model provider API request fails.r0 model_namec0>Xl[TU] U5 gr3)r2r5r6)r8r2r1r9s r:r6ModelAPIError.__init__s$ !r=cJURURUR44$r3)r9r2r1rIs r:rModelAPIError.__reduce__ s~~>>>r=)r2)r2r0r1r0r) rqrrrsrtrurvr6rrxryrzs@r:r'r's9O:"??r=r'c^\rSrSr%SrS\S'S\S'S\S'S \S 'SS S S .SU4S jjjjrSSjrSSjr\ SSj5r Sr U=r $)r(i zFRaised when a model provider response has a status code of 4xx or 5xx.rn status_code object | Noner#zdict[str, str] | Noneheadersrsuggested_model_idNr:r;c>XlX0lUb4UR5VVs0sHupgUR5U_M snnOSUlXPlSUSUSU3nUb USU<S3- n[ T U]X(S9 gs snnf)Nz status_code: z, model_name: z, body: . Did you mean ?)r2r1)r8r#itemslowerr:r;r5r6) r8r8r2r#r:r;kvr1r9s r:r6ModelHTTPError.__init__!s' ELEXA 1 A^b "4!+nZLQUPVW  ) );(>a@ @G J@ BsA8cURURURUR4URUR S.4$)Nr<)r9r8r2r#r:r;rIs r:rModelHTTPError.__reduce__3s@ NN   t :<<&*&=&=   r=cURS5UlURS5UlURb7U=RSUR<S3- slUR4Ulgg)Nr:r;r>r?)getr:r;r1args)r8states r: __setstate__ModelHTTPError.__setstate__=s`yy+ "')),@"A  " " . LLod.E.E-HJ JLDI /r=cURcgURRS5nUcg[U5nUS:ag[U5$![[ 4a Of=f[ U5n[U[5(deURcUR[RS9nU[R"[R5- R5n[SU5$![[ ["4a gf=f)a&Seconds to wait before retrying, parsed from the `Retry-After` response header. Returns `None` when the header is absent or cannot be parsed. The header value is interpreted first as an integer number of seconds, then as an [HTTP-date](https://httpwg.org/specs/rfc9110.html#http.date) string. Nz retry-afterr)tzinfog)r:rHrnfloatr OverflowErrorrr@rrNreplacerutcnow total_secondsmax TypeErrorAssertionError)r8rawseconds retry_timewaits r: retry_afterModelHTTPError.retry_afterDs << ll}- ; #hG{> !M*    .s3Jj(33 33  ('//x||/D hll!;;JJLDsD> !I~6  s*A  A AA#B C00DD)rIr#r:r8r;r3) r8rnr2r0r#r9r:zMapping[str, str] | Noner;r)rkz,tuple[type, tuple[Any, ...], dict[str, Any]])rJrrkr)rkz float | None) rqrrrsrtrurvr6rrKrr\rxryrzs@r:r(r( sP3 1 ""#"^ # A -1)-AAA A * A'AA$ (r=r(c\rSrSrSrSrg)r,idzGA group of exceptions that can be raised when all fallback models fail.rNrrr=r:r,r,dsQr=r,cN^\rSrSrSrSU4SjjrSSjr\S Sj5rSr U=r $) ToolRetryErrorihzMException used to signal a `ToolRetry` message should be returned to the LLM.c>Xl[UR[5(a URO%UR URUR 5n[ TU]U5 gr3) tool_retryr@contentr0_format_error_details tool_namer5r6)r8rbr1r9s r:r6ToolRetryError.__init__ksX$*,,c22   ++J,>,> @T@TU  !r=c4URUR44$r3)r9rbrIs r:rToolRetryError.__reduce__ts~~111r=c D[U5nUSUS:XaSOSU(aSU<3OS3/nUH`nUS(aSRSUS55OS nURU5 URS US S US SUS<S35 Mb SRU5$)a}Format ErrorDetails as a human-readable message. We format manually rather than using ValidationError.from_exception_data because some error types (value_error, assertion_error, etc.) require an 'error' key in ctx, but when ErrorDetails are serialized, exception objects are stripped from ctx. The 'msg' field already contains the human-readable message, so we use that directly. z validation errorr sz for locrc38# UHn[U5v M g7fr3)r0).0rYs r: 7ToolRetryError._format_error_details..s48a3q668s__root__z msgz [type=typez, input_value=input] )lenjoinr)errorsre error_countlineserls r:rd$ToolRetryError._format_error_detailsws&k m,;!3CR,MgpPUV_UbNcvxMy z A89%#((41U844jC LL  LL2ahZwqyk' ~UVW Xyyr=)rb)rbrr)ryz list[pydantic_core.ErrorDetails]rerrkr0) rqrrrsrtrur6r staticmethodrdrxryrzs@r:r`r`hs$W"2  r=r`c:^\rSrSrSrSU4SjjrSSjrSrU=r$)ToolFailedErrorizQException used to signal a failed `ToolReturnPart` should be returned to the LLM.cJ>Xl[TU] URSS95 g)NF) wrap_if_error) tool_failedr5r6model_response_str)r8rr9s r:r6ToolFailedError.__init__s&& 77e7LMr=c4URUR44$r3)r9rrIs r:rToolFailedError.__reduce__s~~ 0 0222r=)r)rrrrrzs@r:rrs[N 33r=rc\rSrSrSrSrg)r*izNError raised when a model stops due to token limit while emitting a tool call.rNrrr=r:r*r*sXr=r*c\rSrSrSrSrg)r+iuWarning raised when in-place mutation of the message history is detected at the end of a run. Mutating messages that are already part of the run's history in place (e.g. `ctx.messages[0].parts[0].content = '...'` from a tool) is not supported: the per-request `gen_ai.input.messages` span attribute caches each message's serialized form, so spans recorded after the mutation may not match the messages actually sent to the model. The run-level `pydantic_ai.all_messages` attribute is always serialized fresh and does reflect the mutation. To transform history mid-run, build new message or part objects instead — e.g. with `dataclasses.replace`, passing the message a new `parts` list (replacing a message in the history and reassigning its `parts` list are both safe) — for instance in a history processor ([`ProcessHistory`][pydantic_ai.capabilities.ProcessHistory]). The warning is best-effort: it's raised when a mutation is detected at the end of a successful run, which covers messages still present in the final history. Errored runs aren't checked — with warnings configured as errors, the warning would displace the run's own exception. Its absence does not guarantee that no stale span was recorded. rNrrr=r:r+r+sr=r+); __future__r _annotationsr'syscollections.abcrrrr email.utilsrtypingr r pydantic_corer _warningsr rr version_infoexceptiongrouprrrrrrrr__all__ Exceptionrr-rrrrr RuntimeErrorrr r!rr"r#r%r&r$r)r'r(r,r`rr*Warningr+rr=r:rs2 -'-%% g?#NVV 8( ( V/ / d090$0y0$y"    " "I L 3r%=r%j} " "L}L m :L0L ?M ?T]TnR^C0R  Y  F 3i 3Y0Y7r=