"j |%SSKJr SSKrSSKrSSKJrJrJrJr SSK J r J r SSK J r SSKJrJr SSKJr SSKJrJrJrJrJrJrJr SS KJr SS KJr SS K J!r! SS K"J#r#J$r$J%r%J&r&J'r'J(r( SS K)J*r* SSK+J,r,J-r- SSK.J/r/J0r0 SSK1J2r2 SSK3J4r4 \(a,SSK5J6r6 SSK7J8r8 SSK9J:r:J;r;Jr>J?r?J@r@ SSKAJBrB SSKCJDrD SrESrFSrGSrHSrISrJSrKS rLS!\MS"'\-\"\5rN\-\"\\,"S#S$9S%9rOS&rPS'rQ\"S(S)9"S*S+55rR\ "S,SS-9rSS.\MS/'S]S0jrT\ "S1SS-9rUS2\MS3'\"S(S49"S5S655rV\W\X\V4rYS7\MS8'S^S9jrZS:r[S_S;jr\S`S<jr]SaS=jr^SbS>jr_ScS?jr`SdS@jraSeSAjrbSfSgSBjjrcShSCjrdSiSDjreS(SE.SjSFjjrfSkSGjrgSlSHjrh\SmSIj5riSnSJjrjSoSKjrkSpSLjrlSfSqSMjjrmSrSNjrn"SOSP\5roS(SQ.SsSRjjrpStSSjrq\ SuSTj5rr\ SSU.SvSVjj5rsSwSWjrtSfSxSXjjruSySYjrvSzSZjrw\"S(S)9"S[S\55rxg){) annotationsN)Callable GeneratorMappingSequence)AbstractContextManagercontextmanager) ContextVar) dataclassreplace)cache) TYPE_CHECKINGAnyClassVarLiteralProtocol TypeAliascast)urlparse)context) get_baggage) INVALID_SPANSpanSpanKindStatus StatusCodeget_current_span)AttributeValue) ConfigDict TypeAdapter)PydanticSerializationErrorto_json)get_traceparent)best_effort_price)PriceCalculation)Self) ModelMessage ModelRequest ModelResponse) AbstractModelModelRequestContextModelRequestParameters)InstrumentationSettings) ModelSettingsgen_ai.agent.namezgen_ai.agent.call.idzgen_ai.conversation.idz gen_ai.systemzgen_ai.request.modelzgen_ai.provider.name) max_tokenstop_pseed temperaturepresence_penaltyfrequency_penaltyzjtuple[Literal['max_tokens', 'top_p', 'seed', 'temperature', 'presence_penalty', 'frequency_penalty'], ...]MODEL_SETTING_ATTRIBUTESbase64)ser_json_bytes)config)r$@iii@iiii@ii)g{Gz?g{Gz?g{Gz?g{Gz?g{Gz?g{Gz?g{Gz?g{Gz?g{Gz@g{Gz@g{Gz$@g{Gz4@g{GzD@g{GzT@T)frozenc.\rSrSr%SrS\S'S\S'Srg) ContentPolicyPaOne span's `include_content`, tagged with the span it was set for. The tag is what makes the variable safe to read. Restoring it is a plain `set` rather than a `reset` (an interrupted streamed run finalizes the context manager in a different `Context`, where `reset` raises), and a `set` lands only in the `Context` that runs it, so the `Context` that opened the request can be left holding a finished request's value. Naming the span means a reader can only honour a policy set for the span in front of it, and anything else fails closed. intspan_idboolinclude_contentN__name__ __module__ __qualname____firstlineno____doc____annotations____static_attributes__rHY/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/_instrumentation.pyrBrBPsLrQrBrG)defaultz ContextVar[ContentPolicy | None]include_content_ctxc[R5nUSL=(a: URUR5R:H=(a UR$)aWhether `span` was opened with content capture, defaulting to `False` when nothing says so. Fails closed on every answer but "this span's own request wanted content": no request open, or a policy belonging to a different span, both mean nothing vouches for exporting content here. N)rTgetrEget_span_contextrG)spanpolicys rRspan_include_contentrZmsF ! $ $ &F   n&..D4I4I4K4S4S"S nX^XnXnnrQtime_to_first_chunkzContextVar[float | None]time_to_first_chunk_ctx)slotsc<\rSrSr%SrS\S'S\S'S\S'S rg ) CachedMessageJsonzNA `MessageJsonCache` entry: one input message's serialized OTel JSON fragment.r(messageobjectpartsbytesfragmentrHNrIrHrQrRr_r_s'X F MO@rQr_rMessageJsonCachec0n[[5nUbX['[[5nUbX ['[[5nUbX0['U$)z]Read agent name, run ID, and conversation ID from OTel baggage and return as span attributes.)rAGENT_NAME_BAGGAGE_KEYRUN_ID_BAGGAGE_KEYCONVERSATION_ID_BAGGAGE_KEY)attrs agent_namerun_idconversation_ids rR get_agent_run_baggage_attributesrosZE34J(2$% + ,F $* !!"=>O"-<)* LrQzcUR(aU$[U[55$![a"nS[ U5R 3sSnA$SnAff=f)alStrip binary data out of a value that's about to be serialized into a span attribute. The attributes that carry whatever a tool or output function produced serialize arbitrary values, so they can't honor `include_binary_content` the way `_convert_binary_to_otel_part` does for message content: `BinaryContent`'s own serialization is a public contract shared with message history, and making it depend on instrumentation would change how it dumps everywhere. The value is redacted up front instead, keeping the media type and the rest of the file metadata, and dropping only the data. That retained set is `BinaryContent`'s own and is wider than the `mime_type` `_convert_binary_to_otel_part` keeps, because this replaces a value the type itself serialized rather than building a spec-shaped message part. Containers and `ToolReturn` are walked, matching the depth at which binary content is honored elsewhere (the sequence in a `UserPromptPart`'s content). A `BinaryContent` nested inside a user's own model is left alone: rebuilding that model to redact one field would change how everything else in the attribute is serialized. z!Unable to redact binary content: N)include_binary_content_redact_binary_contentset ExceptiontyperJ)valuesettingses rRredact_binary_contentrysS"&& F%eSU33 F 3473C3C2DEE Fs) AA AAc fSSKJn SSKJnJn [ U5n[ XXB[[[45(dU$XQ;a[$URU5 [ X5(aJUR[URU5URUR S.UR#U5 $[ X5(ai[UR$U5[UR&U5[UR(U5UR*URS.UR#U5 $[ X5(aS[UR,U5[UR.U5[UR(U5S.UR#U5 $[ U[5(a@UR15VVs0sHupgU[Xq5_M snnUR#U5 $UVs/sHn[Xq5PM snUR#U5 $s snnfs snf!UR#U5 f=f)Nr)DeferredToolRequests) BinaryContent ToolReturn) media_typevendor_metadatakind identifier) return_valuecontentmetadatatoolsr)calls approvalsr)pydantic_ai._deferredr{pydantic_ai.messagesr|r}id isinstancerlisttupleCIRCULAR_REFERENCE_PLACEHOLDERaddr~rrrrrdiscardrrrrrritems)rvactiver{r|r}identitykeyitems rRrrrrs:>%yH eZwX\^cd e e --  JJx!! e + +#..#9%:O:OQW#X #.. > x 1 e ( ( 6u7I7I6 R1%--H25>>6J . x  e 2 20 VD3EOOVL25>>6J x  eW % %"'!.IC+D99!. x BGG&t4Gx Hx sEAH4A'H-AH(H8HH%H)H>H HH0c[RUSS9$![a [RUSS9s$f=f![a- [ U5s$![anSU3sSnAs$SnAff=ff=f)NjsonmodezUnable to serialize: ) ANY_ADAPTER dump_pythonUnicodeDecodeError_BASE64_ANY_ADAPTERrtstr)rvrxs rR serialize_anyrs / G**5v*> >! G&225v2F F G / /u:  /*1#. . //sI8;8; A2 AA2 A.A)!A."A2)A..A2c[U5$![a& [R"USS9R 5s$f=f)aUSerialize `value` to compact JSON bytes, tolerating lone surrogates. `to_json` raises on unpaired surrogates (e.g. text decoded with `errors='surrogateescape'`), which would crash an otherwise-successful run from within instrumentation. The stdlib fallback escapes them, matching the lenient behavior callers had before adopting `to_json`. ),:) separators)r"r!rdumpsencode)rvs rR safe_to_jsonrs=Au~ %Azz%J7>>@@As -==c>[URU/55SS$)u|Serialize one message to its OTel JSON fragment: comma-joined objects without enclosing brackets. A single `ModelMessage` can map to multiple OTel `ChatMessage`s (a `ModelRequest` splits into system/user messages) or to none (an empty request), so the fragment is the whole serialized array with the outer `[` and `]` stripped — fragments then concatenate into a single array. r$)rmessages_to_otel_messages)rwras rRmessage_json_fragmentrs# ::G9E Fq LLrQcUHYnUR"[U55nUcM#URURLdM>UR[ X5:wdMY g g)uDetect whether in-place mutation made any cached message fragment stale. Re-serializes each message that still has a valid cache entry (same `parts` list) and compares bytes — an O(history) pass meant to run once per run, at the end. Entries whose `parts` token no longer matches are skipped: reassigning `.parts` is the supported mutation style and the next serialization would have refreshed them, so they can't have produced a stale span. Detection is deliberately best-effort, covering messages still present at the end of the run: a message that was mutated in place and *then* dropped or rebuilt by a history processor may have produced a stale span without a warning. Closing that gap would require either re-checking cached fragments on every request (the O(history-squared) cost this cache exists to remove) or re-serializing entries as they're evicted (which doubles the serialization cost for processors that rebuild history each request — the workload the cache can't help to begin with). TF)rVrrcrer)rwmessagesr raentrys rRhas_stale_message_jsonr)sP" "W+&   w}},"7"JJ rQc0nU(a;[U5nURURpCU(aX1S'U(aXAS'U$U$![a U$f=f)aMap a model's `base_url` to the OTel `server.*` attributes, omitting what it doesn't carry. `base_url` is an overridable property returning an arbitrary string, and `urlparse` defers authority validation to `hostname`/`port`, so a non-numeric port parses fine and only raises when the port is read. Attributes are best-effort telemetry, so an uninterpretable authority yields no attributes rather than failing the request. zserver.addressz server.port)rhostnameport ValueError)base_url attributesparsedrrs rRserver_attributesrEsj-/J 1h'F#__fkkd/7+,,0=) :    s"A AAc4[U[U0[U5E$)zUBuild the provider and server attributes shared by classic and realtime `chat` spans.)GEN_AI_PROVIDER_NAME_ATTRIBUTEGEN_AI_SYSTEM_ATTRIBUTEr)systemrs rRprovider_attributesr]s' '  H % rQcj0[URUR5E[UR0E$N)rrrGEN_AI_REQUEST_MODEL_ATTRIBUTE model_name)models rRmodel_attributesrfs3  ellENN ; &(8(8 rQcXSS0nUbX['X['UbX['UbX#S'U$)zIBuild the dimensions shared by classic and realtime per-response metrics.gen_ai.operation.namechatgen_ai.response.model)rrr) provider_name request_modelresponse_modelrs rRmodel_metric_attributesrmsK .Ef,MJ 5B12.;*+ 5B12!.<*+ rQrGc|[U5nU(d[U5nUc0$S[U5R50$)Nmodel_request_parameters)#_serialize_model_request_parameters _redact_model_request_parametersrdecode)rrG serializeds rR#model_request_parameters_attributesr~s@55MNJ 5jA  I & Z(@(G(G(I JJrQc[U[5(dg[SU5nURS5n[U[5(a%[SU5HnUR SS5 M URS5bSUS'U$)aPDrop the prompt text the user wrote, or `None` when the shape cannot be redacted. Two fields here are that text: the instructions, whose dynamic parts can be built from deps, and the prompted-output template. Instruction parts keep their origin and ids, so what the parts are and how they cache stays visible. Tool and output *schemas* stay too -- they are the request's structure rather than message content, and `include_model_request_parameters=False` drops the whole attribute for anyone who wants them gone as well. `_serialize_model_request_parameters` falls back to inferring a shape, which for a value it cannot walk -- a tool whose `metadata` holds an arbitrary object, say -- is the request's string representation, instructions and all. There is nothing to redact in a string, so that is reported as unredactable rather than exported. Ndict[str, Any]instruction_partslist[dict[str, Any]]rprompted_output_template)rdictrrVrpop)serialized_parameters parametersrcparts rRrrs +T 2 2&(=>J NN. /E%/7D HHY %8~~01=15 -. rQcj[5RUSS9$![a [U5s$f=f)aSerialize the parameters through their own schema, falling back to inference. `serialize_any` infers a shape from the value, which reads a dataclass as its fields and so loses whatever its class meant. `InstructionPart.id` is exactly that case: its source is a class rather than a tagged field, so inference renders a toolset and a capability sharing an `id` identically and drops the agent's source to `{}`. The declared schema renders the id as the same flat key it serializes to everywhere else. rr)!_model_request_parameters_adapterrrtr)rs rRrrs=702>>?W^d>ee 75667s 22c$SSKJn [U5$)Nrr-)pydantic_ai.modelsr-r rs rRrrs9 - ..rQc0nU(aC[H9n[URU5=n[[-5(dM2X1SU3'M; U$)zeMap the OTel-spec model settings (`max_tokens`, `temperature`, ...) to `gen_ai.request.*` attributes.zgen_ai.request.)r8rrVfloatrD)model_settingsrrrvs rRmodel_settings_attributesrsL,.J+C>#5#5c#::%ECKHH6;_SE23, rQcSSKJn SSKJn URnU(dgUR Hn[ XS5(dMURUR5=n(dM9UR(dML0nURRS5=n(aXS'URRS5=n (aXS'U(dMXul M g)aCopy OTel-relevant metadata from tool definitions onto matching tool call parts. This allows tool definition metadata (e.g. code language hints set by the code-mode toolset) to flow through to OTel events on both the model request span and the agent run span. r)_otel_messages)BaseToolCallPartN code_arg_namecode_arg_language) pydantic_airrr tool_defsrcrrV tool_namer otel_metadata) responserrrrrtool_defrrrs rR annotate_tool_call_otel_metadatars +5$$I  d - -y}}T^^?\3\83\   IK $,$5$5$9$9/$JJ=J5B/2(0(9(9(=(=>Q(RR$R9J"56 =)6&rQc[R"UR=(d /UR=(d /5n/nUHnUR UR 5S:XaM$SUR S.nUR (aUR US'UR(aURUS'URU5 M U$)zBuild OTel-compliant tool definitions from model request parameters. Extracts tool metadata from function_tools and output_tools into a list of tool definition dicts following the OTel GenAI semantic conventions format. withheldfunction)runame descriptionr) itertoolschainfunction_tools output_tools visibility_ofrrparameters_json_schemaappend)r all_toolstool_definitionstoolrs rRbuild_tool_definitionsrs  //52 --3I .0 # 1 1$)) < J ,6 #J   &*&6&6H] #  & &%)%@%@H\ ") rQc0URR5EnUbXS'Ub[UR5US'URbURUS'UR bUR /US'U$)aBuild the `gen_ai.response.*`, usage, and cost span attributes for a completed response. Shared between the classic model-request span (`open_model_request_span`) and the realtime session's per-turn `chat` span so the two paths report the same shape and can't drift. `response_model` is set only when known (always the case for a classic request; a realtime session may not know its model name). rzoperation.costzgen_ai.response.idzgen_ai.response.finish_reasons)usageopentelemetry_attributesr total_priceprovider_response_id finish_reason)rrprice_calculationrs rRresponse_attributesrs-Zx~~/V/V/X,YJ!.<*+$',->-J-J'K #$$$0+3+H+H '()8@8N8N7O 34 rQc[URURURURUR S9$)zYPrice a response, degrading any pricing-data failure to `None` (see `best_effort_price`).)rprovider_api_urlrgenai_request_timestamp)r%rr provider_urlr timestamp)rs rRresponse_price_calculationrs: &&!..,, ( 2 2  rQc&\rSrSrSrSSSjjrSrg)_FinishModelRequestSpanizThe `finish` callback yielded by `open_model_request_span`. `time_to_first_chunk` is the streaming-only TTFT in seconds; non-streaming callers omit it. NcgrrH)selfrr[s rR__call__ _FinishModelRequestSpan.__call__$scfrQrHrrr*r[z float | NonereturnNone)rJrKrLrMrNrrPrHrQrRrrs gfrQrescapedcUR5(dgU(aURXS9 g[U5nURS:waURSUR3O URnUR SU[ U5S.S9 g)aRecord `error` on `span` as an `exception` event. With content capture enabled this is the OTel SDK's own `Span.record_exception`. Without it, only the exception type is kept: the message and stack trace of an exception raised around a tool, a model request or an agent run can quote content the setting is meant to withhold -- a tool retry or failure carries the text the model sees, an exception chained from one repeats that text in its stack trace, a provider's error response can echo the request, and validation errors and user exceptions may echo the rejected arguments. The type and `escaped` formatting match what `Span.record_exception` would have produced. Nrbuiltins. exception)zexception.typezexception.escaped)r) is_recordingrecord_exceptionrurKrL add_eventr)rXerrorrGr error_type type_names rRrr's      e5eJ  J .  !:#:#:";<  $ $  NN;i^abi^j+kNlrQcUR5(dgUR[[RU(a[ U5R SU3OSS95 g)zSet `span`'s status to ERROR, describing it the way `use_span` would have. The SDK's description is `f'{type(exc).__name__}: {exc}'`, which repeats the message the exception event carries, so it is withheld alongside it when content capture is off. Nz: )r)r set_statusrrERRORrurJ)rXr!rGs rRset_error_statusr'DsN     OOzSbU 0D0D/ERw-OhlmrQc#f# Sv g![an[XUSS9 [XUS9 eSnAff=f7f)aRecord exceptions leaving `span`'s scope the way `use_span` would have. For spans opened with `record_exception=False` and `set_status_on_exception=False`, which hands both jobs to the caller. `use_span` recorded the exception unescaped and described the ERROR status with it; both repeat the message, so both follow `include_content`. Enter this around the span's whole scope -- the scope `use_span` covered -- not just the call that may fail, so that failures while finalizing the span still mark it. NF)rGrr)rtrr')rXrGr!s rRrecord_uncaught_errorsr)Qs5 ouUoF s1 1 .).1message_json_cachec #^^^ ^ ^ ^ ^^# URnURURUR5unm [ XT S9m Sm T SUR 3nST 0[ U5E[5Em 0nTR(a*T R[T TRS95 SS0US'[SUS .5R5T S '[T 5nU(a[U5R5T S 'T R[!U55 S m["R%5nTR&R)UT [*R,S S S9m[/TTRS9 ["R1[3TR55R6TR55 SSU UU U U UUU4Sjjjn U T 4v S S S 5 S S S 5 ["R1U5 T(aT"5 g g !,(df  N;=f!,(df  ND=f!["R1U5 T(aT"5 ff=f7f)a Open a `chat ` CLIENT span; yield `(finish, prepared_request_context)`. Shared between `Instrumentation.wrap_model_request` (agent flow) and `InstrumentedModel.request`/`request_stream` (standalone / `direct.model_request*`). Calls `model.prepare_request(...)` internally and yields a request context with the prepared settings/parameters so callers don't have to re-prepare. `finish(response)` annotates the response with OTel tool-call metadata and records outcome attributes. Token/cost metrics are recorded *after* the span closes so backends that aggregate from span attributes don't double-count. `message_json_cache` is a per-run cache reused across requests so the growing input history isn't re-serialized in full each time; the agent flow passes one, one-off requests pass `None`. )rrr rrrurbr)ru propertieszlogfire.json_schemazgen_ai.tool.definitionsNF)rrrset_status_on_exceptionc>^^^^^^[TT 5 TR[TS055 T[m[ [ T[ 5mTR=(d TmSmSUUUUUUU4SjjnUm [T5mTR5(dgTRT RTTT T S9 [TTT5nTbTUS'TRU5 TRT ST35 g)NrcH>[TTT5nTRTTUT5 gr)rrecord_metrics)metric_attributesrrrrrwrr[s rR_record_metrics@open_model_request_span..finish.._record_metricss*(? We(f%++H6GIZ\oprQr*z+gen_ai.client.operation.time_to_first_chunkr-)rr)rupdategetattrrrrrrrrhandle_messagesrrset_attributes update_name)rr[r4attributes_to_setrrrrrr+ operationprepared_parametersprepared_request_contextr2rwrXs`` @@@@rRfinish'open_model_request_span..finishs1;NO!!'$ b"AB *+I J c:.E#FG!)!4!4!E =A!qq"1%?x$H!((**((,55''9 )%8.Rc$d!&2Wj%&ST##$56  I;a !?@rQrr)rprepare_requestrrr rrro include_model_request_parametersr6rrGr"rrrrrTrVtracerstart_as_current_spanrCLIENTr)rsrBrWrE)rwrequest_contextr+rprepared_settings span_namejson_schema_propertiesrprevious_include_contentr?rr<r=r>r2rXs` ` @@@@@@rRopen_model_request_spanrKcs<.  ! !E-2-B-B&&(P(P.** 'Tg I+Qu//01I- 5 !- + ,-J 9;00 /0CU]UmUm n ?Eh=O9:(/Qg0h(i(p(p(rJ$%-.AB0<=M0N0U0U0W ,-/0ABC04N2668? OO 1 1%__!&(- 2   "49Q9Q R # #M$2G2G2I2Q2QS[SkSk$l m& A& A& AP22 2e S v  89    k S R  v  89    sOD&I 1+H!H1AG? HH!%I ? H H HH!!&II c^^[R"5m[R5m[SUU4Sjj5nU$)aSnapshot the current OTel context so it can be re-attached in another task. The streaming continuation composite opens each segment's `request_stream` lazily, in the *consumer* task that iterates the stream, whereas the `chat` span is opened by `wrap_model_request` in a separate task. Those tasks don't share an OTel context, so without re-attaching, span updates driven by `get_current_span()` (e.g. `FallbackModel` recording the resolved inner model) would land on the wrong span. Returns a factory that yields a context manager re-attaching the captured context; the composite enters it around each segment without depending on OpenTelemetry itself. c3v># [R"5n[R5n[R"T5 [R T5 Sv [R"U5 [R U5 g![R"U5 [R U5 f=f7fr) otel_context get_currentrTrVattachrs)previousrJcapturedcaptured_include_contents rRattach_captured_context8capture_current_context..attach_captured_contexts ++-#6#:#:#< H%  89 >     )  # #$< =    )  # #$< =sAB9B ,B9 -B66B9)rGenerator[None])rNrOrTrVr )rTrRrSs @@rRcapture_current_contextrWs>'')H 3668>>* #"rQcSSKJn SSKJn U(a)UR X5nU(aUR U5$[ U5nUb UR$S$)aGet the joined instructions string for the current request. When `model_request_parameters` is provided (normal model request flow), returns the joined content of `instruction_parts` which already includes prompted output instructions and is properly sorted. Falls back to reading `ModelRequest.instructions` from message history when `model_request_parameters` is not available (e.g. OTel span attributes). r)InstructionPart)ModelN)rrYrrZ_get_instruction_partsjoinget_instructions_source instructions)rrrYrZrcsources rRget_instructionsr`sS5(,,XP "''. .%X .F"("46  >$>rQc:SSKJn /n[U5HHn[X15(dMUR U5 [ U5S:Xa OUR cMFUs $ [ U5S:Xa-USnUSn[SUR55(aU$g)aThe request in `messages` whose `instructions` are the ones in force for the current request. Split out from `get_instructions` because the resume path needs the request itself, not just its text: a `before_model_request` hook's rewrite has to land on the message that records the instructions being echoed back, and stamping the wrong one would put instructions on a request that was sent without any. r)r)Nr$c3j# UH)oRS:H=(d URS:Hv M+ g7f)z tool-returnz retry-promptN) part_kind).0ps rR *get_instructions_source..Is+pVoQR{{m+Lq{{n/LLVos13) rr)reversedrrlenr^allrc)rr)last_two_requestsramost_recent_requestsecond_most_recent_requests rRr]r]s2 -/H% g , ,  $ $W -$%*##/ & "/2%6q%9" pViVoVop p p- - rQcR[5nU[Lag[U5=(d S$)aReturn the W3C traceparent of the active OTel span, or None if no valid span is set. Used as a fallback when the graph run was created without a span. In that case, the agent run span is typically set by the Instrumentation capability via `start_as_current_span` while the capability chain is executing, which is exactly when consumers like `OnlineEvaluation` read the traceparent. N)rrr#)rXs rRcurrent_otel_traceparentrpOs'  D | 4 (D(rQc\rSrSr%SrS\S'S\S'S\S'S\S'S\S'S\S 'S rS \S 'S rS \S'SrS \S'\ SSj5r SSjr SSjr SSjr Srg)InstrumentationNamesi]zMConfiguration for instrumentation span names and attributes based on version.ragent_run_span_nameagent_name_attrtool_span_nametool_arguments_attrtool_result_attroutput_tool_span_namezpydantic_ai.tool.deferral.namez ClassVar[str]tool_deferral_name_attrz"pydantic_ai.tool.deferral.metadatatool_deferral_metadata_attrzpydantic_ai.tool.failure_stagetool_failure_stage_attrc :US:Xa U"SSSSSSS9$U"S S S S S S S9$)zCreate instrumentation configuration for a specific version. Args: version: The instrumentation version (2 or 3+) Returns: InstrumentationConfig instance with version-appropriate settings rbz agent runrlz running tooltool_arguments tool_responsezrunning output function)rsrtrurvrwrx invoke_agentr1 execute_toolzgen_ai.tool.call.argumentszgen_ai.tool.call.resultrH)clsversions rR for_version InstrumentationNames.for_versiontsK a<$/ ,-$4!0&?  $2 3-$@!:&4  rQcDURS:XaSU3$UR$)z}Get the formatted agent span name. Args: agent_name: Name of the agent being executed Returns: Formatted span name rz invoke_agent )rs)rrls rRget_agent_run_span_name,InstrumentationNames.get_agent_run_span_names+  # #~ 5":,/ /'''rQcDURS:XaSU3$UR$)zzGet the formatted tool span name. Args: tool_name: Name of the tool being executed Returns: Formatted span name r execute_tool )rurrs rRget_tool_span_name'InstrumentationNames.get_tool_span_names+   . 0"9+. ."""rQcDURS:XaSU3$UR$)zGet the formatted output tool span name. Args: tool_name: Name of the tool being executed Returns: Formatted span name rr)rxrs rRget_output_tool_span_name.InstrumentationNames.get_output_tool_span_names+  % % 7"9+. .)))rQrHN)rrDrr')rlrrr)rrrr)rJrKrLrMrNrOryrzr{ classmethodrrrrrPrHrQrRrrrr]swW.N]M1UU.N]M8 ( # *rQrr)rXrrrF)rr)rvrrwr.rrb)rvrrzset[int]rrb)rvrrr)rvrbrrd)rwr.rar(rrd)rwr.rSequence[ModelMessage]r rfrrF)r str | Nonerdict[str, AttributeValue]r)rrrrrr)rr+rr)rrrAttributeValue | Nonerrrr)rr-rGrFrr)rrrzdict[str, Any] | None)rr-rr)rz#TypeAdapter[ModelRequestParameters])rzModelSettings | Nonerr)rr*rr-rr)rr-rr)rr*rrrPriceCalculation | Nonerr)rr*rr) rXrr! BaseExceptionrGrFrrFrr)rXrr!rrGrFrr)rXrrGrFrrV)rwr.rFr,r+zMessageJsonCache | Nonerz>Generator[tuple[_FinishModelRequestSpan, ModelRequestContext]])rz*Callable[[], AbstractContextManager[None]])rrrzModelRequestParameters | Nonerr)rrrzModelRequest | None)rr)y __future__rrrcollections.abcrrrr contextlibrr contextvarsr dataclassesr r functoolsr typingrrrrrrr urllib.parser opentelemetryrrNopentelemetry.baggageropentelemetry.tracerrrrrropentelemetry.util.typesrpydanticrr pydantic_corer!r"pydantic_graph._utilsr# _genai_pricesr%genai_prices.typesr&typing_extensionsr'rr(r)r*rr+r,r-pydantic_ai.models.instrumentedr.pydantic_ai.settingsr/DEFAULT_INSTRUMENTATION_VERSIONrhrirjrrrr8rOrrTOKEN_HISTOGRAM_BOUNDARIES(TIME_TO_FIRST_CHUNK_HISTOGRAM_BOUNDARIESrBrTrZr\r_rrDrfrorryrrrrrrrrrrrrrrrrrrrrrr'r)rKrWr`r]rprrrHrQrRrsV" BB="*SSS!1-bb3,=1,3&NN]]G2"#D,+6)!7!7 &#s# !#&s:X3VWy,(  $   9CCT^b8c5c o5??T^b4c1c  A A A #3(9#9:):  "8F:/!d / AM%1GP` 80(* $RVK4KJNKK6 7 // 70@26)/ 0ghgbfm: " 37 s%s(s0 s D ssl)#Zae?$?@]??2-` ) $X*X*X*rQ