"jVSSKJr SSKrSSKrSSKrSSKrSSKJr SSKJ r SSK J r J r SSK JrJr SSKJr SSKJrJr SS KJrJrJrJr SS KJr SS KJr SS KJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r' S SK(J)r) S SK*J+r+ S SK,J-r- S SK.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6 S SK7J8r8 S SK9J:r: SSK(J;r;Jr>J?r? SSK@JArA SrBS SjrC\ "SS9"SS55rD\ "SS9"SS\A55rES!SjrFg)") annotationsN)AsyncGenerator)asynccontextmanager) dataclassfield)AnyLiteral)PriceCalculation) MeterProviderget_meter_provider)SpanTracerTracerProviderget_tracer_provider)AttributeValue)to_json) DEFAULT_INSTRUMENTATION_VERSION(TIME_TO_FIRST_CHUNK_HISTOGRAM_BOUNDARIESTOKEN_HISTOGRAM_BOUNDARIESCachedMessageJsonMessageJsonCacheget_instructionsmessage_json_fragmentopen_model_request_span safe_to_json)_otel_messages) RunContext)PydanticAIDeprecationWarning)BaseToolReturnPart ModelMessage ModelRequestModelRequestPart ModelResponseRetryPromptPartSystemPromptPartToolAvailabilityDeltaPart) ModelSettings) UsageBase)KnownModelNameModelModelRequestContextModelRequestParametersStreamedResponse) WrapperModel)instrument_modelInstrumentationSettingsInstrumentedModelcrU(a/[U[5(dUSLa [5n[X5nU$)zYWrap `model` in an `InstrumentedModel` so OTel/Logfire spans are emitted around requests.T) isinstancer3r2)model instruments \/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/models/instrumented.pyr1r13s1*U,=>>  02J!%4 LF)initc*\rSrSr%Sr\"SS9rS\S'SrS\S 'Sr S\S 'Sr S\S '\ r S \S 'Sr S\S'SSSSS\ SS.SSjjrSSjrSSjrSSS.SSjjjrSSjrS SjrSS!SjjrSrg)"r2>aOptions for instrumenting models and agents with OpenTelemetry. Used in: - [`Instrumentation`][pydantic_ai.capabilities.Instrumentation] capability - [`Agent.instrument`][pydantic_ai.agent.Agent.instrument] / [`Agent.instrument_all()`][pydantic_ai.agent.Agent.instrument_all] - [`InstrumentedModel`][pydantic_ai.models.instrumented.InstrumentedModel] See the [Debugging and Monitoring guide](https://pydantic.dev/docs/ai/integrations/logfire/) for more info. F)reprrtracerTboolinclude_binary_contentinclude_content include_model_request_parametersLiteral[2, 3, 4, 5, 6]version$use_aggregated_usage_attribute_namesN)tracer_providermeter_providerr@rArBrDrEc.SSKJn U=(d [5nU=(d [5nSn UR X5UlUR X5UlX0lX@l XPl US;a [S5eUS;a[R"S[SS 9 X`lXpl[#S S S S 9n URR$"S0U DS[&0D6UlURR%SSSS9Ul[#SSSS 9n URR$"S0U DS[.0D6Ulg![*a$ URR$"S0U D6UlNf=f![*a$ URR$"S0U D6Ulgf=f)uCreate instrumentation options. Args: tracer_provider: The OpenTelemetry tracer provider to use. If not provided, the global tracer provider is used. Calling `logfire.configure()` sets the global tracer provider, so most users don't need this. meter_provider: The OpenTelemetry meter provider to use. If not provided, the global meter provider is used. Calling `logfire.configure()` sets the global meter provider, so most users don't need this. include_binary_content: Whether to include binary file data in the instrumentation events: user prompts and model responses, tool returns, the agent's output and the arguments its output function receives, and run and tool deferral metadata. The media type is recorded either way. Binary content is found inside dictionaries, lists and `ToolReturn`s, but not inside your own types: a `BinaryContent` held as a field of a model or dataclass you define is still recorded in full. include_content: Whether to include prompts, completions, and tool call arguments and responses in the instrumentation events. include_model_request_parameters: Whether to emit the `model_request_parameters` span attribute on model request spans. This serializes the full `ModelRequestParameters` (output configuration and every tool definition, including fields that are not sent to the model such as tool `metadata` and, when not requested, `return_schema`). Defaults to `True`. Set to `False` to omit it entirely, which is useful when large tool output schemas make the attribute big enough to strain span export. The OpenTelemetry `gen_ai.tool.definitions` attribute (tool name, description, and parameters) is always emitted regardless of this setting. version: Version of the data format. This is unrelated to the Pydantic AI package version. Defaults to version 5. Versions 2, 3, and 4 are deprecated compatibility formats and emit a `PydanticAIDeprecationWarning` when used. Version 2 uses the newer OpenTelemetry GenAI spec and stores messages in the following attributes: - `gen_ai.system_instructions` for instructions passed to the agent. - `gen_ai.input.messages` and `gen_ai.output.messages` on model request spans. - `pydantic_ai.all_messages` on agent run spans. Version 3 is the same as version 2, with additional support for thinking tokens. Version 4 is the same as version 3, with GenAI semantic conventions for multimodal content: URL-based media uses type='uri' with uri and mime_type fields (and modality for image/audio/video). Inline binary content uses type='blob' with mime_type and content fields (and modality for image/audio/video). https://opentelemetry.io/docs/specs/semconv/gen-ai/non-normative/examples-llm-calls/#multimodal-inputs-example Version 5 is the same as version 4, but CallDeferred and ApprovalRequired exceptions no longer record an exception event or set the span status to ERROR — the span is left as UNSET, since deferrals are control flow, not errors. Version 6 is the same as version 5, but tool results are emitted in a message with `role='tool'` rather than `role='user'`, which is the role the GenAI semantic conventions pair with the `tool_call_response` parts they carry. Opt in to it when your telemetry consumer keys on the message role; it is not the default. use_aggregated_usage_attribute_names: Whether to use `gen_ai.aggregated_usage.*` attribute names for token usage on agent run spans instead of the standard `gen_ai.usage.*` names. Defaults to True to prevent double-counting in observability backends that aggregate span attributes across parent and child spans. Note: `gen_ai.aggregated_usage.*` is a custom namespace, not part of the OpenTelemetry Semantic Conventions. It may be updated if OTel introduces an official convention. r) __version__z pydantic-ai)rz8Instrumentation version must be one of 2, 3, 4, 5, or 6.)rrJrKzTInstrumentation format versions 2, 3, and 4 are deprecated; use `version=5` instead.r) stacklevelzgen_ai.client.token.usagez{token}z/Measures number of input and output tokens used)nameunit description#explicit_bucket_boundaries_advisoryzoperation.costz{USD}z Monetary cost)rPrQz+gen_ai.client.operation.time_to_first_chunkszWTime from issuing a streaming request to the first chunk being surfaced to the consumerN) pydantic_airIrr get_tracerr> get_metermeterr@rArB ValueErrorwarningswarnrrDrEdictcreate_histogramrtokens_histogram TypeErrorcost_histogramrtime_to_first_chunk_histogram) selfrFrGr@rArBrDrErI scope_nametokens_histogram_kwargs$time_to_first_chunk_histogram_kwargss r8__init__ InstrumentationSettings.__init__Rsz ,)B-@-B'?+=+?" %00I #--jF &<#.0P- / )WX X i  MMf,   4X1#',I#  $(JJ$?$?%)%4N%D !#jj99 ':  04>q0 , 151L1L2624\2D .! $(JJ$?$?%)%D ! ( 151L1L262D . s$6)D5 )E&5+E#"E#&+FFc r/nUGH-n[U[5(a[R"UR[ R "[URS9S9HfupE/nUH6n[US5(dMURURU55 M8 UR[R"XFS95 Mh M[U[5(dM[R "SURU5S9nUR"bUR"US'URU5 GM0 U$)N)rD)keyotel_message_parts)roleparts assistant finish_reason)r5r" itertoolsgroupbyrl functoolspartial_otel_message_rolerDhasattrextendrjappendr ChatMessager$ OutputMessagern) rbmessagesresultmessagerkgroup message_partspart otel_messages r8messages_to_otel_messages1InstrumentationSettings.messages_to_otel_messagess35G'<00#,#4#4MMy'8'89KUYUaUa'b$KDGIM %"4)=>>)001H1H1NO!&MM."<"<$"\]$G]33-;;T[TnTnosTtu ((44;4I4IL1 l+  r9c Uc[URU55$/n0nUHnUR[U55nUbURURLa[ XUR[ X55nXd[U5'UR(dMxURUR5 M UR5 URU5 SSRU5-S-$)aRSerialize the input message history to a JSON array. With a `message_json_cache` (agent runs, where the growing history is re-serialized every request), each message's fragment is cached and concatenated, keeping the per-request cost proportional to new messages rather than the whole history. Entries for messages no longer in the input history are evicted, so the cache (and the `parts` lists it keeps alive) stays bounded by the current history even when a history processor prunes or rebuilds messages. Without a cache (one-off requests), the whole history is serialized in a single call. [,]) rrgetidrlrrfragmentrvclearupdatejoin)rbinput_messagesmessage_json_cache fragments fresh_entriesr{entrys r8_input_messages_json,InstrumentationSettings._input_messages_jsons  % > >~ NO O!# *, %G&**2g;7E} 7== @)'==BWX\Bfg)."W+ &~~~  0 &   "!!-0dii **T11r9)rc URU/5n[U5S:XdeUSn[X5nURU5n UR X5R 5[ U/5R 5S.U ES[SSS0SS0S.U (aSSS00O0EUR(aS SS00O0ES .5R 50En URU 5 g) Nr*r)zgen_ai.input.messageszgen_ai.output.messageszlogfire.json_schemaobjecttypearraygen_ai.system_instructionsmodel_request_parameters)r properties) rlenrsystem_instructions_attributesrdecoderrrBset_attributes) rbrresponsespan parametersroutput_messagesoutput_message instructionsr attributess r8handle_messages'InstrumentationSettings.handle_messagess88(D?#q((((+'C )-)L)L\)Z&&*%>%>~%b%i%i%k&2N3C&D&K&K&M1 -1  "7$28'1B3972C #Qo867:KLtv # $DD8&(9KL!# # $fh%1 ( J'r9cU(a@UR(a/S[[R"SUS9/5R 50$0$)Nrtext)rcontent)rArrTextPartr)rbrs r8r6InstrumentationSettings.system_instructions_attributes#sB D00,l#,,&,OP/&(   r9c UR5nUR(dU$UR5VVs0sHup4URSSS5U_M snn$s snnf)aCumulative-usage OpenTelemetry attributes for a run/session span. Remaps `gen_ai.usage.*` to `gen_ai.aggregated_usage.*` when `use_aggregated_usage_attribute_names` is set, so a backend that sums span attributes doesn't double-count the run's cumulative usage against the per-request `chat` spans' `gen_ai.usage.*`. Shared by the classic agent-run span (the `Instrumentation` capability) and the realtime session span so the two can't drift. z gen_ai.usage.zgen_ai.aggregated_usage.r*)opentelemetry_attributesrEitemsreplace)rbusagerrivalues r8aggregated_usage_attributes3InstrumentationSettings.aggregated_usage_attributes,s[335 88 eoeueuewxewWaWZ O-GKURewxxxs AcNSHIn[URUS3S5=n(dM&0UESU0EnURRXg5 MK U(a0[ UR 5nUR RX5 UbURRXC5 gg)N)inputoutput_tokensrzgen_ai.token.type)getattrrr^recordfloat total_pricer`ra) rbrprice_calculationrtime_to_first_chunktyptokenstoken_attributescosts r8record_metrics&InstrumentationSettings.record_metrics9s'C%hnnWoqIIFIG*G.A3G   ! ! ( ( B ' *667D    & &t 8  *  . . 5 56I V +r9) r`r@rArBrXrar^r>rErD)rFzTracerProvider | NonerGzMeterProvider | Noner@r?rAr?rBr?rDrCrEr?)rylist[ModelMessage]returnz list[_otel_messages.ChatMessage])rrrMessageJsonCache | NonerbytesN) rrrr$rr rzModelRequestParameters | Nonerr)rz str | Nonerzdict[str, str])rr)rzdict[str, int])rr$rzPriceCalculation | Nonerzdict[str, AttributeValue]rz float | None)__name__ __module__ __qualname____firstlineno____doc__rr>__annotations__r@rArBrrDrErfrrrrrr__static_attributes__rTr9r8r2r2>sg &FF&#'D' OT -1$d1&EG #E15($5 26/3'+ $15*I59y/y- y !% y  y+/y(y/3yv(202F]2 2B59 $(7;$(*$( $( $( 2 $(4$(L y$-1 WW3W. W * WWr9r2c^\rSrSr%SrS\S'S S U4SjjjrS Sjr\S S Sjj5r Sr U=r $) r3iLzModel which wraps another model so that requests are instrumented with OpenTelemetry. See the [Debugging and Monitoring guide](https://pydantic.dev/docs/ai/integrations/logfire/) for more info. r2instrumentation_settingscT>[TU]U5 U=(d [5Ulgr)superrfr2r)rbwrappedoptions __class__s r8rfInstrumentedModel.__init__Vs# !(/(L3J3L%r9c# [URUUUS9n[URU5upVURR XU5IShvN nU"U5 UsSSS5 $N!,(df  g=f7f)Nr6rymodel_settingsr)r-rrrrequest)rbryrrrequest_contextfinish_rs r8rInstrumentedModel.request^ss .,,)%=  %T%B%BO TXcY_!\\11(LdeeH 8 U TeU Ts.-A<"A+A) A+ A<)A++ A95A<c 8# [URUUUS9n[URU5upgSn[R "5n URR UUUU5IShvN nU7v SSS5IShvN U(a$U"UR5URU 5S9 SSS5 gNMN:!,IShvN (df  NO=f!U(a%U"UR5URU 5S9 ff=f!,(df  g=f7f)Nr)r) r-rrrtime perf_counterrequest_streamrr) rbryrr run_contextrrrresponse_stream request_starts r8r InstrumentedModel.request_streamts.,,)%=  %T%B%BO TXcY_7;O!--/M <<66",  %)) #'++-,;,O,OP],^!U T#'++-,;,O,OP],^#U Ts|-DD  "C,B:-C0B>6 CB<C+D 1 D:C<C>C C C C.DD  DD)rr)rzModel | KnownModelNamerzInstrumentationSettings | NonerNone)ryrrModelSettings | Nonerr.rr$) ryrrrrr.rzRunContext[Any] | Nonerz AsyncGenerator[StreamedResponse]) rrrrrrrfrrrr __classcell__)rs@r8r3r3Ls 652 37M'M0M  MM$-#9   , /3 "$"-"#9 " , " * ""r9r3c[U[[-5(agUS:a8[U[5(d"[U[5(aUR bgg)aThe GenAI role of the message a request part belongs in. Consecutive parts sharing a role make up one message, so a request carrying a tool return and a user prompt splits into a `tool` message followed by a `user` one. From version 6 on, a part that renders as a `tool_call_response` takes the `tool` role the semantic conventions pair it with, which is also the channel the adapters send it on: a tool return and a retry naming a tool both reach OpenAI as `role='tool'`, a retry naming none as `role='user'`. Earlier versions keep those parts on `user`, so a consumer written against them keeps reading the role it was built for. `ToolAvailabilityDeltaPart` gets `system` as the least-bad fit in a closed vocabulary, not as a mirror of the wire. `Role` is `system | user | assistant | tool` and none of those means "the set of tools changed", while the wire form varies by model: a real `SystemPromptPart` where there is no native channel, a `role='system'` entry carrying `tool_addition` blocks on Anthropic, a roleless `additional_tools` item on OpenAI Responses, a tool-search exchange where schemas are withheld. `tool` is the one role that would actively mislead, being paired with `tool_call_response`. systemrMtooluser)r5r&r'r r% tool_name)r~rDs r8rsrssN($(+DDEE A4+,,D/1R1RW[WeWeWqr9)r6r,r7zInstrumentationSettings | boolrr,)r~r#rDintrz_otel_messages.Role)G __future__rrqrorrZcollections.abcr contextlibr dataclassesrrtypingrr genai_prices.typesr opentelemetry.metricsr r opentelemetry.tracer rrropentelemetry.util.typesr pydantic_corerpydantic_ai._instrumentationrrrrrrrrrr _run_contextr _warningsrryr r!r"r#r$r%r&r'settingsr(rr)r+r,r-r.r/wrapperr0__all__r1r2r3rsrTr9r8rs" **(/CQQ3!   %4   %bb! L JWJWJWZ J JJZr9