"j%SSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK r SSK r SSK JrJrJrJrJrJrJrJr SSKJr SSKJrJrJr SSKJrJr SSKJ r J!r!J"r"J#r# SSK$J$r$J%r% SS K&J'r' SS K(J)r) SS K*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2 SSK3r3SS K4J5r5 SS K6J7r7J8r8 SSK9J:r:J;r; SSKJ?r?J@r@JArAJBrB SSKCJDrD SSKEJFrF SSKGJHrHJIrJ SSKKJLrL SSKMJNrN SSKOJPrP \ RS:aSSKRJSrS O\SrS\HrH\+(aSSKTJUrUJVrV SSKWJXrX SSKYJZr[ SSK\J]r] \?"S5r^\A"S5r_\"S \ RS!:HS"9raS#\bS '\"S$SS"9rcS%\bS$'\"S&S'S"9rdS#\bS&'\"S(S'S"9reS#\bS('SoS)jrfSpS*jrI\SqS+j5rg\SrS,j5rh\SqS-j5riSsS.jrjStS/jrkSuS0jrlSvS1jrmSwS2jrn\A"S35roSxS4jrp\!"S5S6\-\o55rq\q\oS-rrS7\bS8'SyS9jrsSS:.SzS;jjrtSoS<jru"S=S>5rv\v"5rwS{S?jrxS|S@jryS}SAjrzS~SBjr{SSCjr|\SSDj5r}SSEjr~SSFjrSSGjrSSHjrSSIjr\GR"SJ5rSSKjrSLrSSMjr\A"SN\\,\\oSO9r"SPSQ\-\o\45rSSRjrSSSjrSSTjrSSUjrSSVjr\8"\$5rSSWjr\SX\\o4r\2SSYj5r\2SSZj5rSS[jrSS\jrSS]jrSS^jrSS_jrSS`jrSSajrSSbjr\GR"Sc\GR4Sd9rSSejrSSfjrSSgjrSShjrSSijrSSjjrSSkjr\GR"Sl5rSSmjrSSnjrg)) annotationsN)AsyncGenerator AsyncIterable AsyncIterator AwaitableCallable GeneratorIterableIterator)Executor)asynccontextmanagercontextmanagersuppress) ContextVar copy_context)MISSING dataclassfields is_dataclass)datetimetimezone)Enum) GenericAlias) TYPE_CHECKINGAnyGeneric TypeAlias TypeGuardget_args get_originoverload)run_sync) BaseModel TypeAdapter) _decorators _typing_extra)JsonSchemaValue) ParamSpecTypeIsTypeVar is_typeddict)typing_objects)is_union_origin) AbstractSpanrun_until_complete)UnsupportedEventLoopError)get_callable_name UserError )BaseExceptionGroup)AgentRunAgentRunResult)GraphRun)messages)ObjectJsonSchema_P_R_disable_threads emscripten)defaultzContextVar[bool]_thread_executorzContextVar[Executor | None]_in_sync_callbackF_abandon_on_cancelcL[R5(a [S5eg)uoReject sync agent entry points inside sync callbacks dispatched by Pydantic AI. Sync tools, output functions, and similar callbacks are dispatched through [`run_in_executor`][pydantic_ai._utils.run_in_executor], which flags the callback's context — whether the callback runs on a worker thread or inline under [`disable_threads`][pydantic_ai._utils.disable_threads]. On a worker thread, a nested sync run starts a second event loop that can deadlock against an async resource bound to the parent run's loop; inline, it would drive the already-running loop and fail anyway. Either way we fail fast with guidance instead. a#`Agent.run_sync()` and `Agent.run_stream_sync()` cannot be used inside a synchronous tool, output function, or other function called during an agent run, as they can deadlock the run. Make the function `async def` and use `await agent.run(...)` or `async with agent.run_stream(...)` instead.N)rDgetr4O/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/_utils.pycheck_no_nested_sync_runrKUs+ z  rIcj[U5$![an[UR5UeSnAff=f)aRun `coro` to completion on the event loop, for use by the sync wrappers. Wraps `pydantic_graph`'s `run_until_complete()` to report an event loop that can't be driven by the caller -- like Temporal's workflow event loop -- as a `UserError`, which is how the rest of the library reports usage mistakes, and which durable execution integrations know to treat as a deterministic failure rather than an infrastructure one to retry. N)_graph_run_until_completer0r4message)coroes rJr/r/gs3*(.. $* ")*s 2-2c## [RS5nSv [RU5 g![RU5 f=f7f)aContext manager to disable thread-based execution for sync functions. Inside this context, sync functions will execute inline rather than being sent to a thread pool via [`anyio.to_thread.run_sync`][anyio.to_thread.run_sync]. This is useful in environments where threading is restricted, such as Temporal workflows which use a sandboxed event loop. On emscripten, sync callbacks already run inline by default because Python threads are unavailable there. Yields: None TN)r@setresettokens rJdisable_threadsrVus<   &E& u%u%A 3A A  A c## [RU5nSv [RU5 g![RU5 f=f7f)a^Context manager to use a custom executor for running sync functions in threads. Inside this context, sync functions will be executed using the provided executor via [`asyncio.get_running_loop().run_in_executor()`][asyncio.loop.run_in_executor] instead of the default [`anyio.to_thread.run_sync`][anyio.to_thread.run_sync]. This is useful in long-running servers (e.g. FastAPI) where thread accumulation from ephemeral anyio worker threads can be a problem, and you want to use a bounded `ThreadPoolExecutor` instead. Args: executor: The executor to use for running sync functions. Yields: None N)rCrRrS)executorrUs rJusing_thread_executorrZs<$   *E& u%u%rWc## [RS5nSv [RU5 g![RU5 f=f7f)aContext manager to abandon worker threads running sync functions when they're cancelled. Inside this context, a cancellation delivered while awaiting a worker thread abandons that thread -- it runs to completion in the background and its result is discarded -- instead of waiting for it to finish. Outside it, [`anyio.to_thread.run_sync`][anyio.to_thread.run_sync] shields the await, so the cancellation is only delivered once the thread returns. This is used around calls that carry a deadline, so that [`anyio.fail_after`][anyio.fail_after] can actually raise `TimeoutError` when a sync function overruns it, rather than only after it returns. Yields: None TN)rErRrSrTs rJabandon_threads_on_cancelr\s<  " "4 (E(   '  'rWch^^^# SUUU4Sjjn[R5(aU"5$[R5nUbC[R"5n[ 5nUR XFRU5IShvN $[U[R5S9IShvN $N(N7f)Nc>[RS5nT"T0TD6[RU5 $![RU5 f=fNT)rDrRrS)rUargsfunckwargss rJcall_with_sync_agent_guard3run_in_executor..call_with_sync_agent_guardsC!%%d+ +((  # #E *  # #E *s 5A )abandon_on_cancel)returnr?) r@rGrCasyncioget_running_looprrun_in_executorrunr"rE)rar`rbrcrYloopctxs``` rJriris++)++##%H'')n))(GG=WXXX4HZH^H^H`a aaY as$BB2B.#B2)B0*B20B2cS[U5;$)Nz)asynchronous generator is already running)str)excs rJ"is_async_generator_already_runningrps 6#c( BBrIc[U[5=(ad [U[5(+=(aH [U[5=(d1 [ U5=(d [ U5=(d [USS5$)zCheck if something is a pydantic model, dataclass or typedict. These should all generate a JSON Schema with `{"type": "object"}` and therefore be usable directly as function parameters. __is_model_like__F) isinstancetyper issubclassr#rr+getattr)type_s rJ is_model_likerxsd 5$ 5,/ /  ui ( :E" :E" :u159 rIcfSSKJn URS5S:XaU$URS5=n(auSnURU5(a[URS05RU[ U5S5=n(a'URS5S:Xa[ U5(dU$U$U"S5e) Nr2r3rtobject$ref#/$defs/$defszSchema must be an object) exceptionsr4rG startswithlen _contains_ref)schemar4refprefixresolveds rJcheck_object_json_schemars% zz&X%  6" " " NN6 " "#ZZ488S[]9KLLL V$0!(++O 233rIc[U[5(aSU;agUR5nOUn[SU55$)z6Recursively check if an object contains any $ref keys.r{Tc3t# UH.n[U[[-5=(a [U5v M0 g7fN)rsdictlistr).0items rJ _contains_ref..s*WQVz$t ,Dt1DDQVs68)rsrvaluesany)objitemss rJrrs=#t S=  WQVW WWrITcPUc[S[U5<S35e[U5$)z6Validate and normalize a tool-prepare callback result.zPrepare function zg returned `None`; return `[]` to expose no tools, or return `tool_defs` to pass them through unchanged.)r4r1r)result prepare_funcs rJcheck_tools_prepare_func_resultrs; ~ 1, ?BCd d   <rIc$\rSrSr%SrS\S'Srg)Someiz(Analogous to Rust's `Option::Some` type.rvaluerHN)__name__ __module__ __qualname____firstlineno____doc____annotations____static_attributes__rHrIrJrrs 2 HrIrrOptionc&^ # [5nU/[U5-m SU 4Sjjn[R"5IShvN n[ U5HupEUR X$U5 M SSS5IShvN /nT H+n [U [5(aeURU 5 M- U$NoN;!,IShvN (df  NP=f![ a7n[UR5S:XaURSnSUlUeeSnAff=f7f)akRun awaitables concurrently via an `anyio` task group and return results in input order. Unlike `asyncio.gather`, a failure in one coroutine cancels the rest instead of leaving them as orphan background tasks. If exactly one task fails, its exception is re-raised directly to match `asyncio.gather`'s shape; multi-failure cases propagate as an `ExceptionGroup`. c,># UIShvN TU'gN7frrH)indexrOresultss rJ_rungather.._run&s#s  Nr2rT)rintrO Awaitable[T]rfNone) Unsetranyiocreate_task_group enumerate start_soonr8r~__suppress_context__rsappend) corossentinelrtgirOegro final_resultsrrs @rJgatherrswH (zCJ6G$ **,,$U+ dt,,-, Mfe,,,,V$ -,,,  r}}  "--"C'+C $I s{"DC B/C 'B3* C 5B16C :5D/C 1C 3C 9B< : C C D C D2D  DDmsgc# UH)nUR5(aMURUS9 M+ [R"SS9 [R "USS06IShvN SSS5 gN !,(df  g=f7f)akCancel any tasks still running and wait for them to finish unwinding. Cleanup-only: results and exceptions from `tasks` are intentionally discarded so a cancelled child cannot replace an exception already propagating in the caller. Use after `asyncio.create_task` when an outer cancel/exception means the spawned tasks must be torn down before the caller exits. rT)shieldreturn_exceptionsN)donecancelr CancelScopergr)rtaskstasks rJcancel_and_drainr;sdyy{{ KKCK    $ 'nne:Bc[RS:ag[R"5nUb+UR 5S:a[R "S5egg![a gf=f)uRe-assert an external cancellation that a completed step absorbed (level-triggered backstop). A step the run awaits — a Temporal activity under `WAIT_CANCELLATION_COMPLETED`, an `event_stream_handler`, a capability hook — can catch the `CancelledError` injected by `task.cancel()` and return normally. asyncio even *delegates* a task's cancellation to the future it is currently awaiting, so an awaited child task that absorbs its cancel silently completes the awaiting task too. Either way the cancellation is an edge the framework never sees, and without a re-check the run would complete as if it was never cancelled. Well-behaved consumers of their own cancellation, like `asyncio.timeout()` and AnyIO cancel scopes, balance `Task.cancelling()` back down with `Task.uncancel()`, so a positive count at a step boundary is treated as a still-pending cancellation of the run and re-raised. This is deliberately a *policy*, not a proof of external intent: code awaited by the run that cancels its own task as an internal wake-up and suppresses the `CancelledError` without calling `Task.uncancel()` (a pre-3.11 idiom) will be read as a cancelled run. Call this only after the just-completed step's results have been recorded to message history, so cancellation never discards completed work. The re-raise is a fresh `CancelledError`: the originally-injected exception object (and any message it carried) was consumed by whatever absorbed it and cannot be recovered — the cancellation *state* is re-asserted, not the original exception. On Python 3.10 `Task.cancelling()` does not exist and this is a no-op: an absorbed external cancellation cannot be reliably detected there, so the cancellation guarantee is documented as best-effort on 3.10. r5NrzEpydantic-ai: re-asserting a cancellation absorbed by a completed step)sys version_inforg current_task RuntimeError cancellingCancelledError)rs rJraise_if_cancellingrOsl6 '!##% DOO-1$$%lmm2 sA A('A(c\rSrSrSrSrg)riuz(A singleton to represent an unset value.rHN)rrrrrrrHrIrJrrus2rIrcU[L$r)UNSET) t_or_unsets rJis_setr~s U ""rIc [U5(de[U5Vs1sHo"RiM nnUR5U- =n(a<[ S[ U5R SSR[U5535e[R"U5nXPLa"[ S[ U5R S35eUR5Hupg[RXVU5 M U$s snf)uReturn a shallow copy of a dataclass instance with `changes` applied to its fields. Use instead of `dataclasses.replace` on instances of subclassable dataclasses: `replace` reconstructs through `type(obj).__init__`, which crashes for subclasses whose custom `__init__` doesn't accept the dataclass field names (https://github.com/pydantic/pydantic-ai/issues/6674). Copying preserves the subclass and all of its state, and never re-runs `__init__`/`__post_init__` — the caller must refresh any state it derives from the changed fields. Not a drop-in for `replace`: fields declared `init=False` are carried over rather than reset, so call sites that rely on `replace` resetting derived state (e.g. per-run state isolation) must keep using `replace`. zInvalid field name(s) for : , zCannot replace fields on z/: its `__copy__` does not return a new instance) rrnamekeys TypeErrorrtrjoinsortedcopyrrz __setattr__)rchangesf field_namesunknownnew_objrrs rJreplace_no_initrs    #)#;/;a66;K/,,.;..w.4T#Y5G5G4H499U[\cUdKeJfghhiinG~3DI4F4F3GGvwxx}}  7%0' N0sC:c# U(aBURS5 [[R[5 UIShvN SSS5 [ USS5nUbU"5IShvN ggN-!,(df  N1=fN7f)zGClean up pending task and async iterator after group_by_temporal exits.z)Cancelling group_by_temporal pending taskNaclose)rrrgrStopAsyncIterationrv)r aiteratorrs rJ_cleanup_temporal_grouprsk   ?@ g,,.@ AJJB Y$ /F h B A s97BA/A-A/"B&B'B-A// A=9BcP# [USS5nUbU"5IShvN ggN7f)z9Close an async iterable if it exposes an `aclose` method.rN)rv)streamrs rJaclose_if_supportedrs*3:68T3RF hs &$&c# /nUHn[U5IShvN M [U5S:XaUSeU(a [ SU5egN0![anURU5 SnAMfSnAff=f7f)z>Close every async iterable, then propagate any close failures.Nr2rzErrors closing async iterables)r BaseExceptionrrr8)streamserrorsrerrors rJ aclose_allrsw"$F !%f- - -  6{aQi  !A6JJ . ! MM%  !s=A5A A A ,A5 A  A2A-'A5-A22A5c^^^# Sm[U5mTc SU4SjjnO SUUU4SjjnU"57v [TT5IShvN gN![TT5IShvN f=f7f)auGroup items from an async iterable into lists based on time interval between them. Effectively, this debounces the iterator. This returns a context manager usable as an iterator so any pending tasks can be cancelled if an error occurs during iteration. Usage: ```python async with group_by_temporal(yield_groups(), 0.1) as groups_iter: async for groups in groups_iter: print(groups) ``` Args: aiterable: The async iterable to group. soft_max_interval: Maximum interval over which to group items, this should avoid a trickle of items causing a group to never be yielded. It's a soft max in the sense that once we're over this time, we yield items as soon as `anext(aiter)` returns. If `None`, no grouping/debouncing is performed Returns: A context manager usable as an async iterable of lists of items produced by the input async iterable. Nc:># TShvN nU/7v MN g7frrH)rrs rJasync_iter_groups,group_by_temporal..async_iter_groupss' df  is c># TbTS:dS5e/nSnUcTnOT[R"5U- - nTc[R"[ T55m[R "T4US9IShvN up4U(aKUR 5R5nURU5 SmUc[R"5nOU(a U7v /nSnMNj![a U(aU7v Smgf=f7f)Nrz+soft_max_interval must be a positive number)timeout) time monotonicrg create_taskanextwaitpoprrr) buffergroup_start_time wait_timer_rrsoft_max_intervalrs rJrrs%05F!5K = K!F-1 #+ 1I!2T^^5EHX5X YI<#..uY/?@D!( dWi HH@#xxz002 d+#+3/3~~/?, LF'+$OI .!"(L# s6A2D5C 6 DC""?D"C=:D<C==D)rfzAsyncIterator[list[T]])aiterr) aiterablerrrrs ` @@rJgroup_by_temporalrsa:$(Di I    0 ,0 ,d7!!%dI666%dI666s3$A% A A%A A% A"AA""A%cT[U5$![an[5UeSnAff=f)zGet the next item from a sync iterator, raising `StopAsyncIteration` if it's exhausted. Useful when iterating over a sync iterator in an async context. N)next StopIterationr)iteratorrPs rJ sync_anextr $s, *H~ * ")*s ' "'cF[R"[RS9$)N)tz)rnowrutcrHrIrJnow_utcr/s <<8<< ((rIcUR=(d [5UlUR=(d UUlUR=(d UUlg)a]Fill in framework-tracked metadata (`timestamp`, `run_id`, `conversation_id`) that's still unset. Producer-supplied values are preserved; only unset fields are filled in. Centralizing the field list here means a new framework-tracked field only needs to be handled in one place, rather than every site that materializes a message into the history. N) timestamprrun_idconversation_id)rNrrs rJfill_run_metadatar3s< ))6WYG^^-vGN%55HGrIc fURU:wa![SUR<SUSU<S35eg)zgRaise `UserError` if an `UploadedFile` references a different provider than the model it was passed to.z!UploadedFile with `provider_name=z` cannot be used with z". Expected `provider_name` to be `z`.N) provider_namer4)rsystemmodel_type_names rJvalidate_uploaded_file_providerr?sK V#/0B0B/EE[\k[lm//5j <  $rIc<UR=(d [5$)zTType guard that either returns the tool call id or generates a new one if it's None.) tool_call_idgenerate_tool_call_id)ts rJguard_tool_call_idrHs >> 4244rIz[^a-zA-Z0-9_-]c.[RSU5$)z4Replace characters outside `[a-zA-Z0-9_-]` with `_`.r)TOOL_NAME_SANITIZERsub)rs rJsanitize_tool_namer!Ws  " "3 --rIpyd_ai_cP[[R"5R3$)zBGenerate a tool call id. Ensure that the tool call id is unique. )TOOL_CALL_ID_PREFIXuuiduuid4hexrHrIrJrr_s! " "4::<#3#3"4 55rISourceT)boundrBcT\rSrSrSrS SjrS SjrS SjrSSjrSSjr SSjr S r g )PeekableAsyncStreamijzWraps an async iterable of type T and allows peeking at the *next* item without consuming it. We only buffer one item at a time (the next item). Once that item is yielded, it is discarded. This is a single-pass stream. cXlSUl[UlSUl[ R "5Ul[5Ul g)NF) source _source_iterr_buffer _exhaustedrLock _source_lockrR _pull_scopes)selfr-s rJ__init__PeekableAsyncStream.__init__qs7 59"'  "JJL47ErIc# UR(a[$[UR[5(d UR$UR c[ UR5Ul[R"5nURRU5 URIShvN [UR 5IShvN UlSSS5IShvN URURRU5 sSSS5 $NgNK![aF SUl[ssSSS5IShvN URRU5 sSSS5 $f=fN!,IShvN (df  N=f!URRU5 f=f!,(df  O=fSUl[$7f)zlReturns the next item that would be yielded without consuming it. Returns None if the stream is exhausted. NT)r0rrsr/rr.rr-rrr3addr2rrdiscard)r4scopes rJpeekPeekableAsyncStream.peek}sR ??L$,,..<<     $ %dkk 2D     E    ! !% ( 1,,,%-243D3D-E'E -, ||!!))%0! -'E-%*.$ -,,!!))%0! %-,,,!!))%0!  sA?GF)F .D/F 2E/4D D D F !E-"F 1F) GF DE*1E/2 F >E?F F) G)E**E/-F /F 5E86 F F  F&&F)) F73GcZ# [UR5IShvN [5$N 7f)z9Returns True if the stream is exhausted, False otherwise.N)rsr;rr4s rJ is_exhausted PeekableAsyncStream.is_exhausteds +U33+s +)+cU$rrHr>s rJ __aiter__PeekableAsyncStream.__aiter__s rIc`# UR(a[e[UR[5(dURn[ UlU$UR c[UR5Ul[R"5nURRU5 URIShvN [UR 5IShvN sSSS5IShvN URRU5 sSSS5 $NWN;N-![a SUlef=f!,IShvN (df  O=fURRU5 O !URRU5 f=fSSS5 O!,(df  O=fSUl[e7f)zYields the buffered item if present, otherwise fetches the next item from the underlying source. Raises StopAsyncIteration if the stream is exhausted. NT)r0rrsr/rrr.rr-rrr3r8r2rr9)r4rr:s rJ __anext__PeekableAsyncStream.__anext__sM ??$ $$,,..<>5> ) /R/rIc^^SU4SjjmUU4Sj[T55nTRRSSRU5S3$)aExclude fields with values equal to the field default. A field is shown when its value differs from an explicit `default`. Fields that are required or that only have a `default_factory` have no plain default to compare against here, so they are always shown (the `default_factory` is deliberately not called: some factories are impure, e.g. `uuid7()` or `now_utc()`, and `repr()` must stay observational). The comparison is guarded because a value whose `__ne__`/`__bool__` does not return a plain `bool` (e.g. a numpy array or pandas `Series`/`DataFrame`) would otherwise make `repr()` raise `ValueError`, which breaks logging and traceback formatting of the message history. c>UR(dgUR[Lag[[ TUR 5UR:g5$![ a gf=f)NFT)reprrBrrJrvr Exception)rr4s rJ include_field3dataclasses_no_defaults_repr..include_fieldsTvv 99  aff-:; ;  s+A A"!A"c3># UH:nT"U5(dMURS[TUR5<3v M< g7f)=N)rrv)rrrWr4s rJr/dataclasses_no_defaults_repr..s7`|!}]^O_5166(!GD!&&145|s A-A(r))rrrfrJ)r __class__rr)r4kv_pairsrWs` @rJdataclasses_no_defaults_reprr`sA avd|`Hnn)) *!DIIh,?+@ BBrIc[RS:a0SSKn[UR XR R S95$[[R"U55$)uThe annotations written on `cls` itself, without forcing lazy (PEP 649) evaluation. On Python 3.14+ annotations are evaluated lazily, so a field referencing a class defined later in the module must not be evaluated while the class is still being built — `@dataclass` defers it, and anything inspecting a class from `__init_subclass__` has to as well. `Format.FORWARDREF` never raises `NameError`, so an unresolvable annotation comes back as a `ForwardRef` instead. )r6rN)format)rr annotationlibrget_annotationsFormat FORWARDREFinspect)clsrds rJown_annotationsrjsP 7"M11#>R>R>]>]1^__ '', --rIcl[U5R5Hn[R"[ U55(d[R"U5(aMD[ U[ 5(aUO [USS5nUb,[R"SUR55(aM g g)aWhether `@dataclass` would give `cls` fields of its own, i.e. it annotates a non-`ClassVar` name. Annotations are inspected without being evaluated (see [`own_annotations`][]), so a `ClassVar` that can't be resolved yet is still recognized from the way it was written. __forward_arg__Nz^(typing\.)?ClassVar\bTF) rjrr, is_classvarr rsrnrvrematchstrip)ri annotationtexts rJdeclares_dataclass_fieldsrss &c*113  % %j&< = =A[A[\fAgAg ' C88zgjRcei>j  )BDJJL Q Q 4 rIc [U5Vs0sH"o3R[XR5_M$ nnURU5 U"S0UD6$s snf)u~Shared utility for typed-part narrowers — preserves base fields when promoting to a typed subclass. Construct a new dataclass instance from `src`'s fields, overriding selected ones. Lets typed-part narrowers stay maintainable when fields are added to the base class — base-class field changes flow through automatically instead of needing every narrower to be updated by hand. rH)rrrvupdate)srcdst_cls overridesr field_valuess rJcopy_dataclass_fieldsrzsQKQQT+#V+QFFGC,@$@+L#V "  "\ ""$Ws)Ac,[RU5$r) _datetime_tavalidate_pythonrPs rJnumber_to_datetimer~$s  ' ' **rI.cgrrHrs rJis_async_callabler+sRUrIcgrrHrs rJrr/sCFrIc8[U[R5(a-URn[U[R5(aM-[R "U5=(d2 [ U5=(a [R "UR5$)zCorrectly check if a callable is async. This function was copied from Starlette: https://github.com/encode/starlette/blob/78da9b9e218ab289117df7d62aee200ed4c59617/starlette/_utils.py#L36-L40 )rs functoolspartialrarhiscoroutinefunctioncallable__call__rs rJrr3sh S)++ , ,hh S)++ , ,  & &s + l 0k'B]B]^a^j^jBklrIc\# [R"U5(a UIShvN $U$N7f)aAwait `value` if it is awaitable, otherwise return it unchanged. Use this to resolve the result of calling a callback typed as `X | Awaitable[X]`, regardless of how the awaitable is produced: an `async def`, or a plain `def` / callable object that *returns* a coroutine. [`is_async_callable`][pydantic_ai._utils.is_async_callable] can't detect the latter because it inspects the callable rather than its result, so dispatching on it alone drops such a callback's coroutine un-awaited. N)rh isawaitable)rs rJ await_mayber?s*5!!{ Ls !,*,cZSSKJn [U5nUcgX!L=(d [U5UL$)a,Check if a callable takes a `RunContext` as its first argument. Args: callable_obj: The callable to check. Returns: `True` if the callable takes a `RunContext` as first argument, `False` otherwise. Raises: UserError: If the callable has annotations that cannot be resolved at runtime. r2) RunContextF) _run_contextrget_first_param_typer ) callable_objrfirst_param_types rJtakes_run_contextrMs4)+L9  ) WZ8H-IZ-WWrIcl[R"U5n[[ UR R 555nUn[U5n[U[R5(d2[[U5SS5nUbUn[U5RnOg[R "[R""U55nUR-U5$![a gf=f![a gf=f![$an['SU<SUS35UeSnAf[([*4a gf=f)aGet the type annotation of the first parameter of a callable. Handles regular functions, methods, and callable classes with __call__. Uses Pydantic internals to properly resolve type hints including forward references. Args: callable_obj: The callable to inspect. Returns: The type annotation of the first parameter, or None if the callable has no introspectable annotations. Raises: UserError: If the callable has annotations that cannot be resolved at runtime. Nrz*Unable to resolve the type annotations of ra6. This typically happens when a type is imported inside an `if TYPE_CHECKING:` block in a module that uses `from __future__ import annotations`. Pydantic AI resolves these annotations at runtime to determine how to call the function, so every type used in its signature needs to be imported at runtime as well.)rh signature ValueErrorriter parametersrrr1rsr%_function_likervrtrr&get_function_type_hintsunwrap_wrapped_function NameErrorr4rAttributeErrorrG)rsigfirst_param_namecallable_for_hintsr call_func type_hintsrPs rJrras<  -S^^%8%8%: ;< & \ *D lK$>$> ? ?D. DA  !*  %..D "::;;^;^_q;rs  >>* ++G  "  81#F[ [    ~ &s@C,C/$*C? C,+C,/ C<;C<? D3 DD32D3c.[R"U5$)zResolve type hints for a function, including forward references. Wraps `pydantic._internal._typing_extra.get_function_type_hints` so callers don't need to import Pydantic internals directly. )r&r)ras rJrrs  0 0 66rIcSU;a9USnURS5(aUSSnURX35nSU3US'SU;a'USnUR5Hn[Xa5 M SU;a([ US[ 5(aUSn[Xq5 SU;aUSnUHn [X5 M SU;a([ US[ 5(aUSn [X5 S H"n X;dM X n U Hn [X5 M M$ S U;a*[ US [ 5(aUS n [X5 ggg) z@Update $refs in a schema to use the new names from name_mapping.r{r|N propertiesr prefixItemsadditionalProperties)anyOfoneOfallOfnot)rrGr_update_mapped_json_schema_refsrsr)s name_mappingr original_namenew_namepropspropr prefix_itemsradditional_propskeyword keyword_items not_schemas rJrrsQ {i >>* % %GM#'' EH"8*-AfIq+,\?LLND +D ?#!| 1W:t44 !' '<-.}-=  D +D ?!"z!4J2KT'R'R+,-C+D'(8G/ <23*M%/C&/ zj5400%&uX ' A1zrIcUnURS5=n(aUSU3nSnUnUSU3nX2;aUS- nUSU3nX2;aMU$)zXGenerate a unique definition name by appending the schema title and/or a numeric suffix.titlerr2)rG)rrall_defsrrroriginal_new_names rJ_unique_def_namersuH 7##u#WAdV$ A 1QC H   Q'(!-   OrIc0n/nUGH>nSU;aURU5 MUR5nURSS5n0nUR5H2upgXa;a XqU'XeU'MXqU:wdM[ XcU5XV'XqXV'M4 SnU(amSnUR5HNupgXe;dM [R "U5n [ X5 X:wa[ XcU5XV'XXV'SnMJXeU'MP U(aMmUR5Hn [ XU5 M [ X55 URU5 GMA X!4$)aMerges the `$defs` from different JSON schemas into a single deduplicated `$defs`, handling name collisions of `$defs` that are not the same, and rewrites `$ref`s to point to the new `$defs`. Returns a tuple of the rewritten schemas and a dictionary of the new `$defs`. r}NTF)rrrrrdeepcopyrr) schemasrrewritten_schemasrdefsschema_name_mappingr def_schemachangedupdatedrs rJmerge_json_schema_defsrs` +-H.0 &  $ $V , zz'4(.0!% D#!+,0D)~-,E!4!:;"&48D1%1g,224H +H,>@S T5 (D  (_b  &&rIz,```(?:\w+)?\r?\n(\{.*?\})\s*(?:\r?\n?```|\Z))flagscURS5(aU$[R"[U5nU(aUR S5$U$)N{r2)rrnsearch_MARKDOWN_FENCES_PATTERNgroup)rrros rJstrip_markdown_fencesrs= s II. 5E {{1~ KrIc[U5n[R"U5(a4URn[U5n[R"U5(aM4U$r)r r, is_annotated __origin__tporigins rJ_unwrap_annotatedr%sH ^F  % %f - - ]]B  % %f - - IrIc[R"U5(a URn[U5n[ U5n[ U5(a[ S[U555$g)zZExtract the arguments of a Union type if `tp` is a union, otherwise return an empty tuple.c38# UHn[U5v M g7fr)r)rargs rJr!get_union_args..5sD|&s++|srH)r,is_typealiastype __value__rr r-tuplerrs rJget_union_argsr-sR&&r** \\ 2 B ^FvDx|DDDrIc[R"5nUbUR5(a+[R"5n[R "U5 U$![a SnNSf=fr)rgget_event_loopr is_closednew_event_loopset_event_loop) event_loops rJrr:sc++- Z1133++- z*   sA A+*A+c"[U[5$)z?Check if obj is a dict, narrowing the type to `dict[str, Any]`.)rsrrs rJ is_str_dictrFs c4  rIcURS5=(dM US:H=(dA URS5=(d) US:H=(d URS5=(d US;$)zCheck if a media type represents text-like content. Returns True for `text/*`, JSON, XML, YAML, and their structured syntax suffixes. ztext/zapplication/jsonz+jsonzapplication/xmlz+xml)zapplication/x-yamlzapplication/yaml)rendswith) media_types rJis_text_like_media_typerKsr g& D + + D   w ' D * * D   v &  D C C rIc@SRSUSUS3USUS3/5$)zIFormat text file content with delimiters for inlining into a text prompt. z-----BEGIN FILE id="z" type="z"-----z-----END FILE id=")r)rrr identifiers rJformat_inlined_text_filerZs9 99":,hzl& I   F 3  rIz [\s",.:]+cZ[[RUR555$)aRoughly estimate the number of tokens in a string by splitting on whitespace and punctuation. Shared by the test models, which report a plausible usage count without pulling in a tokenizer. Blank text counts as one token, so a caller that wants zero for it guards the call itself. )r_TOKEN_SPLIT_PATTERNsplitrp)rrs rJestimate_string_tokensrhs! #))$**,7 88rIc4[R"U5n[R "[ R"U55RSn[U[R5(d0$0n[URURSS5GHaupE[U[R5(aR[UR[R5(a)[URR[5(dMy[U[R 5(a UR"nO/[U[R$5(aUR&/nOMUVs/sHLn[U[R(5(dM$UR*UR,;dM@UR*PMN snH/n[R."URR5X8'M1 GMd U$![[4a 0s$f=fs snf)aVThe docstring under each member of an `Enum`, by member name. Pydantic reads a docstring under a model field with `use_attribute_docstrings`, but not one under an enum member; this does the same for enums, so each option can be described where it is declared. Empty when the source is not available, such as for a class defined in the REPL. rr2N)rh getsourceOSErrorrastparsetextwrapdedentbodyrsClassDefzipExprrConstantrnAssigntargets AnnAssigntargetNameid __members__cleandoc) rir- class_def docstringspreviousnoderrrs rJenum_member_docstringsr qs""3' (//&1277:I i . . !#JinninnQR.@A tSXX & &:djj#,,+O+OT^_c_i_i_o_oqtTuTu  h + +&&G #-- 0 0'G -4vW6 63888TYY_YbYbfifufuYuYVYYWvD&// 0@0@AJ wB + Y  &ws#G=-#HH0H=HHrK)rOz Awaitable[_R]rfr?)rfGenerator[None])rYr rfr )razCallable[_P, _R]r`z_P.argsrbz _P.kwargsrfr?)rorrfrJ)rwrrfrJ)rr'rfr=)rz'JsonSchemaValue | list[JsonSchemaValue]rfrJ)rzIterable[T] | Nonerrrflist[T])rrrfr )rzasyncio.Task[Any]rrzrfr)rrIrfz TypeGuard[T])rrrrrfr)rzasyncio.Task[Any] | NonerzAsyncIterator[Any]rfr)rzAsyncIterable[Any]rfr)rzIterable[AsyncIterable[Any]]rfr)rzAsyncIterable[T]rz float | Nonerfz&AsyncGenerator[AsyncIterable[list[T]]])rz Iterator[T]rfr)rfr)rNz_messages.ModelMessager str | Nonerr rfr)rz_messages.UploadedFilerrnrrnrfr)rz_messages.ToolCallPart | _messages.ToolReturnPart | _messages.RetryPromptPart | _messages.NativeToolCallPart | _messages.NativeToolReturnPartrfrn)rrnrfrn)rfrn)rQz3AgentRun | AgentRunResult | GraphRun[Any, Any, Any]rfrn)r4rrfrn)rirtrfdict[str, Any])rirtrfrJ)rvrrwrtrxrrfr)rQz int | floatrfr)rzAwaitableCallable[T]rfzTypeIs[AwaitableCallable[T]])rrrfzTypeIs[AwaitableCallable[Any]])rrrfr)rzT | Awaitable[T]rfr)rCallable[..., Any]rfrJ)rrrfz Any | None)rarrfr )rr rdict[str, str]rfr)rrnrr rzdict[str, dict[str, Any]]rfrn)rzlist[dict[str, Any]]rfz6tuple[list[dict[str, Any]], dict[str, dict[str, Any]]])rrrnrfrn)rrrfr)rrrfztuple[Any, ...])rfzasyncio.AbstractEventLoop)rrrfzTypeGuard[dict[str, Any]])rrnrfrJ)rrrnrrnrrnrfrn)rrrnrfr)riz type[Enum]rfr) __future__r _annotationsrrgrrrhrnrrrr%collections.abcrrrrrr r r concurrent.futuresr contextlibr rr contextvarsrr dataclassesrrrrrrenumrtypesrtypingrrrrrrr r!ranyio.to_threadr"pydanticr#r$pydantic._internalr%r&pydantic.json_schemar'typing_extensionsr(r)r*r+typing_inspectionr,typing_inspection.introspectionr-pydantic_graph._utilsr.r/rMpydantic_graph.exceptionsr0pydantic_graph.utilr1r~r4rexceptiongroupr8pydantic_ai.agentr9r:pydantic_graphr;rNr< _messagestoolsr=r>r?platformr@rrCrDrErKrVrZr\rirprxrrrrrrrrrrrrrrrrrr rrrrcompilerr!r$rr(r+rRr`rjrsrzr|r~AwaitableCallablerrrrrrrrDOTALLrrrrrrrrrrr rHrIrJr-s2       (DD0@@'    $+90FF,;@1!gG+ :'''t_ T]%/0BCLL\hLh%i"i0:;MW[0\-\&01De&T#T(22FPU'V$V $ *&&*&&0((*b(C$4( X CL  71:   GdN "f>EI=(#nL  #<  " !    K\7\74@\7+\7\7~*) I 5%5  5jj!23L.  6 )=#5}Q?O Pf-'!W*-f-R0C: ." #8$ +S)A,./ U U F F m X(5,p7'BT 9'x::&U]_]f]fg  ! zz,/9rI