"jSrSSKJr SSKJrJr SSKJr SSKJ r J r SSK J r SSK JrJr SSKJr SS KJrJrJr SS KJr SS KJr \(aSS KJr SS KJr SSKJr SSjr SSjr!"SS\\5r"SSjr#g)zTAuto-injected capability that drains the pending message queue at appropriate times.) annotations) TYPE_CHECKINGAny)ModelRequestNode)PendingMessagePendingMessageQueue)fill_run_metadata)AbstractCapabilityCapabilityOrdering) UserError)EnqueuedMessagesEvent ModelMessage ModelRequest) RunContext)End) _agent_graph)ModelRequestContext) FinalResultcLURn[U[5(deU$N)pending_messages isinstancer)ctxqueues g/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/capabilities/_pending_messages.py_queuers(  E e0 1 11 1 Lcf/nURHn[XAUS9 URU5 M U$)aStamp a pending message's messages' `timestamp` / `run_id` / `conversation_id` where unset. Each [`PendingMessage`][pydantic_ai._enqueue.PendingMessage] carries one or more built [`ModelMessage`][pydantic_ai.messages.ModelMessage]s (assembled at enqueue time by [`PendingMessage.from_content`][pydantic_ai._enqueue.PendingMessage.from_content]); this only fills in framework-tracked metadata that the producer left unset, so producer-supplied values are preserved. )run_idconversation_id)messagesr append)pendingfallback_run_idfallback_conversation_idr!messages r_stamped_messagesr's7$&H##'Kcd $ OrcL\rSrSrSrSSjr\S Sj5rS SjrSr g) PendingMessageDrainCapability3uMDrains the pending message queue at appropriate times. - `'asap'` messages drain at the earliest opportunity: into the next [`ModelRequest`][pydantic_ai.messages.ModelRequest] via `before_model_request`, or — if the agent would otherwise terminate — redirected through a new `ModelRequestNode` at the end of the run. - `'when_idle'` messages drain only when the agent would otherwise terminate and no `'asap'` messages remain, after any `'asap'` redirect. This capability is always auto-injected and placed outermost via [`CapabilityOrdering`][pydantic_ai.capabilities.abstract.CapabilityOrdering]. Final draining happens at the graph-advancement seam after the full capability hook chain, so user ordering constraints cannot make the queue close before a hook has had a chance to redirect an apparent [`End`][pydantic_graph.End]. c[SS9$)N outermost)position)r )selfs r get_ordering*PendingMessageDrainCapability.get_orderingDs !;77rcgr)clss rget_serialization_name4PendingMessageDrainCapability.get_serialization_nameGsrc T# [U5RS5nUHn[XARURS9nUR R U5 UR R U5 UR[UR[U5S95 M U$7f)uDrain `'asap'` messages into the upcoming model request. Each drained request is appended to both `request_context.messages` (so the model sees it this step) and `ctx.messages` (so it persists in the agent's message history). Stamps `timestamp`/`run_id`/`conversation_id` if the producer didn't — `ModelRequestNode.run()` only stamps `self.request` (the current node's request), and capabilities downstream of us might append more messages, so we can't rely on that fixup. Emits one [`EnqueuedMessagesEvent`][pydantic_ai.messages.EnqueuedMessagesEvent] per drained [`enqueue`][pydantic_ai.tools.RunContext.enqueue] call, in enqueue order, describing the messages exactly as delivered here. asapr$r% enqueue_idr!) r pop_priorityr'rr r!extend _emit_eventr r:tuple)r.rrequest_contextdrainedr#r!s rbefore_model_request2PendingMessageDrainCapability.before_model_requestKs$+**62G(cNaNaH  $ $ + +H 5 LL   ) OO1W=O=OZ_`hZij k sB&B(r2N)returnr )rC str | None)rRunContext[Any]r?rrCr) __name__ __module__ __qualname____firstlineno____doc__r/ classmethodr4rA__static_attributes__r2rrr)r)3sA 8 -  rr)c [U[5(dU$[U5R5up#U(d U(dU$/UQUQnUVs/sH#nU[ XPR UR S94PM% nnUVVV s/sHupxUHoPM M n nnn U Sn [U [5(d"[S[U 5RS35eUH[upXUH$n XLdM URRU 5 M& UR[UR[!U5S95 M] [#U S9$s snfs sn nnf)aDrain pending messages after all capability hooks if the agent would terminate. Drain `'asap'` messages first (anything that arrived after the most recent `before_model_request` and would otherwise be lost), then `'when_idle'` messages. Each priority is appended independently so the history keeps the priority split visible (matches pi-mono's separate steering / follow-up turns). On the wire, `_clean_message_history` re-merges adjacent requests with compatible instructions, so the model still sees one turn. The last resulting request becomes the redirect [`ModelRequestNode`][pydantic_ai._agent_graph.ModelRequestNode]'s request; any earlier ones are appended to `ctx.messages` so they appear in history before the redirect. Emits one [`EnqueuedMessagesEvent`][pydantic_ai.messages.EnqueuedMessagesEvent] per drained [`enqueue`][pydantic_ai.tools.RunContext.enqueue] call, in enqueue order. r8z|Enqueued content must end with a `ModelRequest` so the agent has a request to respond to, but the last queued message is a `z`.r9)request)rrr drain_at_endr'rr rr typerFr!r"r=r r:r>r) rresult leftover_asap when_idler@r#stamped_rr&r!finals rdrain_pending_messages_at_endrXhsX& fc " " &c{779M  * * *G   G  gzz\_\o\o p   4;[7/AJZwJZ7H[ RLE e\ * * 115e1E1E0Fb J  &-!'G# ##G,(  !W-?-?%P`Ja b &- E **9\s *E?EN)rrErCr)r#rr$rDr%rDrCzlist[ModelMessage])rrErR8_agent_graph.AgentNode[Any, Any] | End[FinalResult[Any]]rCrY)$rJ __future__rtypingrrpydantic_ai._agent_graphrpydantic_ai._enqueuerrpydantic_ai._utilsr !pydantic_ai.capabilities.abstractr r pydantic_ai.exceptionsr pydantic_ai.messagesr rrpydantic_ai.toolsrpydantic_graphr pydantic_airpydantic_ai.modelsrpydantic_ai.resultrrr'r)rXr2rrrgsZ"%5D0T,RR((6.  )   *2$6s$;2j;+ ;+ D;+>;+r