"j1%SrSSKJr SSKrSSKrSSKrSSKrSSKJ r SSK J r SSK J r SSKJrJr \(aSS KJr S r"S S 5r"S S5r\R,"SS55r\ "SSS9rS\S'\ SSj5rSSjrg)uRun-scoped cancellation controller for first-party run cancellation. First-party cancellation (`AgentRun.cancel()`, `RunContext.cancel()`) is implemented by cancelling the asyncio task that drives the run: that wakes whatever the run is blocked on (a model stream, tool tasks, a suspended-job poll) and reuses the exact same teardown machinery as external cancellation — streams are closed, in-flight tool tasks are cancelled and drained, suspended server-side jobs are best-effort cancelled, and completed work is recorded to message history. At the outer edge of [`Agent.iter()`][pydantic_ai.agent.Agent.iter], after teardown, the resulting `CancelledError` is translated back into [`RunCancelled`][pydantic_ai.exceptions.RunCancelled] — but only if the cancellation was ours: - The controller counts every `Task.cancel()` it issues. On catching `CancelledError`, the outer edge consumes exactly that many cancellations via `Task.uncancel()` (mirroring what `asyncio.timeout()` does for its own cancellation). - If `Task.cancelling()` is still positive afterwards, an *external* cancellation raced in; it wins, and the `CancelledError` keeps propagating as itself. On Python 3.10, `Task.cancelling()`/`Task.uncancel()` don't exist, so the race cannot be disambiguated: a requested first-party cancellation is translated to `RunCancelled` even if an external cancellation arrived at the same time (documented degraded behavior). The controller is runtime-only state: it holds a live task reference and is never serialized. ) annotationsN) Generator)contextmanager) ContextVar) TYPE_CHECKINGAny)AgentRun)CancellationToken RunBindingRunCancellationprovide_run_bindingtake_run_bindingcT\rSrSrSrS Sjr\S Sj5rS SjrS Sjr S Sjr Sr g ) r *aA thread-safe handle for cancelling one or more agent runs. A token is permanently cancelled after [`cancel`][pydantic_ai.CancellationToken.cancel] is called. The same token may be passed to multiple concurrent runs, in which case all of them are cancelled. cdSUl[5Ul[R"5UlgNF) _cancelledset_registrations threadingLock_lockselfs P/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/_cancel.py__init__CancellationToken.__init__2s!47E^^% chUR URsSSS5 $!,(df  g=f)z(Whether cancellation has been requested.N)rrrs r cancelledCancellationToken.cancelled7ZZ??ZZ # 1cUR UR(a SSS5 gSUl[UR5nSSS5 WHnUR 5 M g!,(df  N(=f)zpCancel every live run registered with this token. This method is idempotent and may be called from any thread. NT)rrtuplercancel)r registrations cancellations rr'CancellationToken.cancel=sZ ZZZ#DO!$"5"56M *L    !*ZsA'A'' A5cUR UR(aSnOURRU5 SnSSS5 W(aUR 5 gg!,(df  N'=f)NTF)rrraddr')rr) should_cancels r _registerCancellationToken._registerMsQ ZZ $ ##'' 5 %      !  Zs 2A  A.cUR URRU5 SSS5 g!,(df  g=fN)rrdiscard)rr)s r _unregisterCancellationToken._unregisterWs' ZZ    ' ' 5ZZs 2 A)rrrNreturnNoner6bool)r)r r6r7) __name__ __module__ __qualname____firstlineno____doc__rpropertyr!r'r.r3__static_attributes__rrr r *s/& ## " "6rr c\rSrSrSrSSjr\SSj5r\SSj5rSSSjjr SSjr SS jr SS jr SS jr SS jrSS jrSSjrSrg)r \aMTracks first-party cancellation of a single agent run. One instance per run, shared (by reference) between the run's public handles and its internals. The task driving the run binds itself with [`bind`][pydantic_ai._cancel.RunCancellation.bind] at each step boundary, so `cancel()` always cancels the task currently doing the work. cSUlSUl0UlSUlSUl[ R "5Ul/Ulgr) _owner_loop_issued _requested _finishedrRLockr_tokensrs rrRunCancellation.__init__ds:37 7; 8: __& 02 rchUR URsSSS5 $!,(df  g=f)zVWhether a first-party cancellation has been requested. Sticky for the life of the run.N)rrHrs rcancel_requested RunCancellation.cancel_requestedmr#r$czUR [UR5sSSS5 $!,(df  g=f)zXWhether a [`CancellationToken`][pydantic_ai.CancellationToken] was attached to this run.N)rr9rKrs r has_tokenRunCancellation.has_tokenss!ZZ %ZZs, :NcRUc[R"5nUcgUR XlUR 5Ul[RS:acXR;aT[URUUR55URU'URUS:Xa URU UR(a1UR(d XR;aURU5 SSS5 g![a gf=f!,(df  g=f)a.Bind the task that is currently driving the run. Called at run start and at each step boundary, so manual `AgentRun.next()` driving from a different task than the one that started the run still gets cancelled correctly. If a cancellation was requested before any task was bound (e.g. `cancel()` on a lazily-started run) or was issued to a previous driving task, it is (re-)delivered to this one. A caller that catches and uncancels the controller's own cancellation takes over its bookkeeping; the issued count is re-synchronized at the next step boundary. N r)asyncio current_task RuntimeErrorrrEget_looprFsys version_inforGmin cancellingrHrI_issuertasks rbindRunCancellation.bindys < ++- <  ZZKDJ7*t||/C &)d);T__=N%O T"<<%* T*t~~$ll:R D!Z    ZsDCD DD D&cUR UR(dUR(a SSS5 gSUlURnURnUbUbUR 5(a SSS5 gSSS5 [ R"5nUWLaUR5 gURUR5 g!,(df  NV=f![a SnNQf=f)zaRequest cancellation of the run from any thread. Idempotent; a no-op once the run has finished. NT) rrIrHrErFdonerWget_running_looprY_delivercall_soon_threadsafe)rownerloop running_loops rr'RunCancellation.cancels ZZ~~Z#DOKKE::D}  Z 1=  "335L 4  MMO  % %dmm 4!Z L s"$C;CC  C C/.C/cUR URnUR(d'Ub$UR5(dXR;a SSS5 gUR U5 SSS5 g!,(df  g=fr1)rrErIrerGr_)rris rrgRunCancellation._deliversR ZZKKE~~%**,,%<rr?rNrQrbr'rgr_rurzrrr@rArrr r \s^3## && "B5. $'&R rr cR\rSrSr%Sr\R "\S9rS\ S'Sr S\ S'S r g) r izBridge an `AgentRunEvents` handle to the run it starts. The handle exists before its lazy background run, so it owns the cancellation controller. `Agent.iter()` later attaches the live run state while retaining that same controller. )default_factoryr r)NzAgentRun[Any, Any] | None agent_runrA) r:r;r<r=r> dataclassesfieldr r)__annotations__rr@rArrr r s) %0$5$5o$VL/V+/I(/rr zpydantic_ai.run_binding)defaultzContextVar[RunBinding | None]_current_run_bindingc## [RU5nSv [RU5 g![RU5 f=f7f)zGSet the binding for runs started in this context, resetting it on exit.N)rrreset)bindingrts rrrs< ! $ $W -E* ""5)""5)sA 3A A  A c^[R5nUb[RS5 U$)zConsume and return the pending binding at most once. Consuming prevents nested agent runs from inheriting the outer handle's binding. N)rrpr)rs rrrs+ #&&(G  & Nr)rr r6zGenerator[None])r6zRunBinding | None)r> __future__r _annotationsrWrr[rcollections.abcr contextlibr contextvarsrtypingrrrunr __all__r r dataclassr rrrrrArrrs03 %%"% k/6/6deeP 0007AAZdh6i3i**r