"jXuSrSSKJr SSKrSSKJrJr SSKJrJ r J r J r SSK J r JrJrJr SSKJr SSKJrJr SS KJr SS KJrJr SS KJr SS K J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r)J*r+J,r,J-r-J.r.J/r/ SS K0J1r1J2r2 SSK3J4r4J5r5J6r6J7r7J8r8J9r9 SSK:J;r;Jr>J?r? SSK@JArA SSKBJCrC SSKDJErEJFrFJGrGJHrHJIrIJJrJJKrKJLrL \ (a&SSKMJNrN SSKOJPrPJQrQ SSKRJSrS SSKTJUrU SSKVJWrW SSK@JXrX SSjrY\ "SS\E\55rZg)zKInstrumentation capability for OpenTelemetry/Logfire tracing of agent runs.) annotationsN) AwaitableCallable)KW_ONLY dataclassfieldreplace) TYPE_CHECKINGAnyClassVarLiteral) set_baggage)attachdetach) StatusCode)ValidationErrorto_json)_usage_attribution) DEFAULT_INSTRUMENTATION_VERSIONInstrumentationNamesMessageJsonCache get_agent_run_baggage_attributesget_instructionshas_stale_message_jsonopen_model_request_spanrecord_exceptionrecord_uncaught_errorsredact_binary_content safe_to_json serialize_anytime_to_first_chunk_ctx)UNSETUnset)ApprovalRequired CallDeferredMessageHistoryMutatedWarning ModelRetryToolFailedErrorToolRetryError) ModelMessage ModelResponseRetryPromptPart ToolCallParttool_return_ta)ToolDefinition)RunUsage)AbstractCapabilityCapabilityOrdering RawToolArgsValidatedToolArgsWrapModelRequestHandlerWrapOutputProcessHandlerWrapRunHandlerWrapToolExecuteHandler) RunContext)ModelRequestContextModelRequestParametersInstrumentationSettings) OutputContext)AgentRunResult) AgentDepsTcSSKJn U"5$)zHLazy import to avoid loading the OTel SDK eagerly at module import time.rr=pydantic_ai.models.instrumentedr>r=s e/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/capabilities/instrumentation.py_default_settingsrF@sG " $$c\rSrSr%SrSrS\S'\"SS9rS\S '\"S S S S 9r S \S'\"SS S S 9r S\S'\"\ S S S9r S\S'\"SS S S 9r S\S'\"SS S S 9rS\S'\"\S S S 9rS\S'\"S S S S 9rS\S'S\S'S rS!\S"'\"\S S S9rS#\S$'\"S%S S S9rS&\S''S7S(jrS8S)jr\SSS\SS*.S9S+jj5rS:S,jrS;S-jrSS0jrS?S1jr S S2.S@S3jjr!SAS4jr"SBS5jr#S6r$g)CInstrumentationGaCapability that instruments agent runs with OpenTelemetry/Logfire tracing. When added to an agent via `capabilities=[Instrumentation(...)]`, this capability creates OpenTelemetry spans for the agent run, model requests, and tool executions. Other capabilities can add attributes to these spans using the OpenTelemetry API (`opentelemetry.trace.get_current_span().set_attribute(key, value)`). TzClassVar[bool]_safe_at_runtimec[5$N)rFrGrEInstrumentation.XsFWFYrG)default_factoryr>settingsagentF)defaultreprinitstr _agent_namerint_new_message_index)rQrUrVr0 _run_usageNzlist[ModelMessage] | None_last_messageszModelRequestParameters | None_last_model_request_parameterszstr | None | Unset_last_formatted_instructionsbool_variable_instructionsr_instrumentationz str | Noneidr_message_json_cachec6[R"[5$rM)r for_versionrrNrGrErOrPs 4 @ @A` arGr_instrumentation_namescb[R"URR5UlgrM)rrfrRversionrgselfs rE __post_init__Instrumentation.__post_init__s&:&F&Ft}}G\G\&]#rGc[SS9$)N outermost)position)r3rjs rE get_orderingInstrumentation.get_orderings !;77rGinclude_binary_contentinclude_content include_model_request_parametersri$use_aggregated_usage_attribute_namesc *SSKJn U"U"UUUUUS9S9$)aBuild an `Instrumentation` capability from a YAML/JSON spec. Accepts every serializable [`InstrumentationSettings`][pydantic_ai.models.instrumented.InstrumentationSettings] option. The OTel `tracer_provider` and `meter_provider` fields can't be expressed in YAML and default to the global providers (typically configured via `logfire.configure()`). `id` is deliberately not accepted. An agent has one instrumentation configuration -- which is what the class-level default `id` says -- so there is nothing for a spec to name, and two `Instrumentation` capabilities resolve to one rather than colliding. YAML form: capabilities: - Instrumentation: {} # default settings - Instrumentation: version: 2 include_content: false rr=rs)rRrC)clsrtrurvrirwr>s rE from_specInstrumentation.from_specs,: L,'= /1Q5Y   rGc# [U5nUR(aURROS=(d SUl[ UR 5Ul[5UlU$7f)z0Return a fresh copy for per-run state isolation.NrS) r rSnamerXlenmessagesrZr0r[)rkctxinsts rEfor_runInstrumentation.for_runsLt}.1iiCIINNTMg"%cll"3#* sA.A0c# UR(aU"5IShvN $URnURnURnUR(aURR OSUUUR =(d SUR=(d SSUS3S.nURb,URRUR5nUbXvS'URRURU5USSS9n[XRS 9 [ R""UR$5 ['S U5n ['S UR =(d SU S 9n ['S UR=(d SU S 9n [)U 5n Sn U"5IShvN n UR(aUR+5(aqUR-S[/U R0[25(a U R0O5[5[7[9U R0U555R;55 U [=U 5 UR+5(aU bU R?5n U R@n O+URB=(d URDn UR@n URGURIXU 55 U bGURJ(a6[MXF :; OO 1 1--j9*!&(- 2   #D:R:R S  ) )$// :()a>ab & 2243HI)fh! 556GH !  q 5F1 2  & &9=E5 6   ,];PQY;d-e f m m oE* ::4??K        "7$#Z_ZeZeZghZgRVRS1:a3E3Evw/2MZgh#&(:#$fh  is>(Ec# URUl[URX RS9unnUR Ul[URUR 5n[UR[5(dX`R:waSUl X`l U"U5IShvN nU"U[R"5S9 UsSSS5 $N)!,(df  g=f7f)N)message_json_cacheT)time_to_first_chunk)rr\rrRrdmodel_request_parametersr]rrr^r#r`r!get)rkrrequest_contextrfinishprepared_request_contextcurrent_instructionsresponses rEwrap_model_request"Instrumentation.wrap_model_requestQs.66 $T]]OXpXp qv  $ 3K2c2cD /$4((*B*[*[$ d??GG'+L+LL26D/0D -$_55H 81H1L1L1N O3r q(6)r qs/0C*A;C-C.C C*C C'#C*c# URnURU5nSUR3US'SXvR'URR R URUR5USSS9nURR(ahUR5(aS[R"XRRURS9n URURU R55 [!XURRS9 UR#[$R&5 SSS5 Ue!,(df  Ue=f7f) a'Emit an error span for a tool call whose argument validation failed. Runs only after every other capability has declined to recover the error, so a recovered validation failure produces no span. The span keeps the `execute_tool` operation name so tracing backends group it with other tool spans, and sets `pydantic_ai.tool.failure_stage: 'validation'` to distinguish it from execution failures. With content capture enabled, the span records the retry prompt built from the error as the tool result. That is the exact message the model receives when the agent loop handles the failure; raw-mode callers (e.g. sandboxed dispatch via `handle_call(wrap_validation_errors=False)`) surface the raw exception to the calling code instead, and the recorded prompt is just the rendered description of the failure. zinvalid tool call: r validationFr) tool_name tool_call_idrN)rg_tool_span_attributesrtool_failure_stage_attrrRrrget_tool_span_namerurr, from_errorrrtool_result_attrmodel_response_record_exception set_statusrERROR) rkrcalltool_defargserrorrrrretrys rEon_tool_validate_error&Instrumentation.on_tool_validate_error{s0++//5 ':$..9I$J =!4@ 001 ]] ! ! 7 7  $ $T^^ 4!"$) 8 }},,1B1B1D1D'225NNaearars""5#9#95;O;O;QR d4==;X;X Y OOJ,, -     sA=E?CE  E EEc URnURRnSURURS.U(aUR UR 50O0E[5ESUR3[S0U(aUR SS0URSS00O0E00S.ES.5R5S.E$) u:Build the span attributes shared by `wrap_tool_execute` and `wrap_output_process`. Both spans use `gen_ai.operation.name='execute_tool'` and the same `gen_ai.tool.*` attributes — they only differ in how the result is serialized and which exceptions are special-cased, which stays in the call-site `try/except`. execute_tool)rgen_ai.tool.namegen_ai.tool.call.idzrunning tool: rr)rrr)rr) rgrRrurrtool_arguments_attrargs_as_json_strrrrr)rkrrrus rEr%Instrumentation._tool_span_attributess++--77%3 $#'#4#4 HW))4+@+@+BC\^  /0  ,DNN+;<#*$ # /!& 9 9FH;M % 6 68J "$ #-//1 #$ fh/  rG)handle_tool_control_flowc # URnURnURnURR UUSSS9n U"5IShvN n U(aNU R5(a9U RUR4[CU [D5(aU OU"U 55 SSS5 U $Nc![ [ 4Ga6n U(d*[XUS9 U R[R5 eU RUR[U 5R5 U(aU R5(a{U R bn[#U R U5n [%U 5R'5n O!![([*4a [-U 5n Of=fU RUR.U 5 UR0S:a)[XUS9 U R[R5 eSn A f[2anU(aPU(aIU R5(a4U RUR4UR6R955 [XUS9 U R[R5 eSnAf[:anU(aOU(aHU R5(a3U RUR4UR<R?SS95 [XUS9 U R[R5 eSnAf[@a/n[XUS9 U R[R5 eSnAff=f!,(df  W $=f7f)uOpen a `gen_ai`-flavoured tool/output span around `action`. Records the serialized result on success (when `include_content` is enabled and the span is recording), records the exception and sets status `ERROR` on failure. When `handle_tool_control_flow` is True, the helper additionally special-cases `CallDeferred`/`ApprovalRequired` (deferrals are control flow, not errors) and records `ToolRetryError`'s retry prompt as the tool result before re-raising. Output-function spans leave that flag off — `ToolRetryError` is treated as a plain error there because the retry prompt is recorded on the surrounding request/agent spans, and `CallDeferred`/`ApprovalRequired` never reach output processing. FrNr) wrap_if_error)#rRrgrurrr%r$rrrrrtool_deferral_name_attrr__name__rrrrr TypeError ValueErrorrUtool_deferral_metadata_attrrir)r tool_retryrr( tool_failedmodel_response_str BaseExceptionrrW)rk span_nameractionserialize_resultrrRrrurrexcredacted_metadata metadata_stres rE_run_tool_spanInstrumentation._run_tool_spans,==++"22 __ 2 2 !"$) 3 ' %xP4#4#4#6#6""**(55F;KF;Sa j ]( "23 /%dQOOJ$4$45""5#@#@$s)BTBTU"t'8'8':':s||?W(=cllH(U%?'./@'A'H'H'J %z2?'+,='> ?&&u'H'H,W##a'%dQOOJ$4$45! +DDUDUDWDW&&u'='=q||?Z?Z?\]!$?K 0 01" +DDUDUDWDW&&u'='=q}}?_?_ns?_?tu!$?K 0 01  !$?K 0 01 U  j sAM#M B5B3B5AM) M#3B55MBG7&F?G7FG7FAG77 MBJ MBL M*M  MM M M#c^^^# TRU5nUR(aSUS'TRTRR UR 5UUU4SjU4SjSS9IShvN $N7f)NTzpydantic_ai.realtimec>T"T5$rMrN)rrsrErO3Instrumentation.wrap_tool_execute..,s 74=rGct>[R"[UTR55R 5$rM)r. dump_jsonrrRrvaluerks rErOr -s*>+C+C%eT]];,fh,rG)rrrrr)rrrrgrr)rkrrrrrrs` `` rEwrap_tool_execute!Instrumentation.wrap_tool_executesv//5 <<26J- .((11DDT^^T!(&*)    sA*A6/A40A6c &^^^# UR(dT"T5IShvN $TRnTRRnURnU(a UR OUR =(d SnSUS.[5ESSU30En Ub UR(aURU S'U(a9[[TTR55R5XR'[S0U(aURS S0URS S00O0ES 00EUbUR(aS00O0ES .5R5U S 'TRUR!U5U UU4S jU4SjS9IShvN $GNjN7f)uEmit a span for output-function execution. Output processing for plain validation (no function) is not span-worthy — the validated value is the model's response itself, no user code ran. We open a span only when an output function will execute, regardless of whether the output arrived via a tool call. The span name reflects the function (or tool name when the function name is unavailable, e.g. union processors). Noutput_functionr)rrrzrunning output function: rrrrrrc>T"T5$rMrN)rrsrErO5Instrumentation.wrap_output_process..rs 76?rGcp>[[[UTR555R 5$rM)rr rrRrr s rErOrss*<3E4==IJ,fh,rG)rrrr) has_functionrgrRru tool_callr function_namerrrrrrrrrget_output_tool_span_name) rkroutput_contextrrrrur span_targetrs ` `` rEwrap_output_process#Instrumentation.wrap_output_process7s ** ( (++--77",, .7i))^=Y=Y=n]n &4 +& /0&  6{mD &  Y%;%;090F0FJ, - 4@AVW]_c_l_lAm4n4u4u4wJ00 1,3   +"557I!22VX4F   ' 7@6KPYPfPf-r2ln  - &(! ()$((55kB!* )   O)N s"FF E$FFFF)rgr^r\r]r`)returnNone)rr3) rtr_rur_rvr_rizLiteral[2, 3, 4, 5, 6]rwr_rrI)rRunContext[Any]rrI)rRunContext[AgentDepsT]rr8rzAgentRunResult[Any])rr rzlist[ModelMessage]rzdict[str, Any] | Nonerz#dict[str, str | int | float | bool])rr!rr;rr6rr+) rr!rr-rr/rr4rzValidationError | ModelRetryrr5)rr-rdict[str, Any]) rrWrr"rzCallable[[], Awaitable[Any]]rzCallable[[Any], str]rr_rr ) rr!rr-rr/rr5rr9rr ) rr!rr?rr rr7rr )%r __module__ __qualname____firstlineno____doc__rK__annotations__rrRrXrZr0r[r\r]r"r^r`rcrrdrgrlrq classmethodrrzrrrrrrrrr__static_attributes__rNrGrErIrIGs(,n+ ).>Y(ZH%Z_W5uEKE#AEFF ERJR 16dUZ0[N-[DIRV]binDo"$Ao7)[r& __future__rrcollections.abcrr dataclassesrrrr typingr r r r opentelemetry.baggagerropentelemetry.contextrrrropentelemetry.tracer pydantic_corerr pydantic_airpydantic_ai._instrumentationrrrrrrrrrrrrrr r!pydantic_ai._utilsr"r#pydantic_ai.exceptionsr$r%r&r'r(r)pydantic_ai.messagesr*r+r,r-r.pydantic_ai.toolsr/pydantic_ai.usager0abstractr2r3r4r5r6r7r8r9pydantic_ai._run_contextr:pydantic_ai.modelsr;r<rDr>pydantic_ai.outputr?pydantic_ai.runr@rArFrIrNrGrEr>sQ"/::88BP*2*,lk,&   3NG0.,% n (-n  n rG