tPjDpdZddlmZddlmZmZddlmZmZddl m Z ddl m Z m Z mZmZddlmZddlmZdd lmZmZe rdd lmZed Gd dZed GddZed GddZddZddZd dZd!dZ d"dZ d#dZ!d$dZ"d%dZ#d&dZ$d'dZ%y)(uThe single translation layer between a request's metadata and the spans. Every relevant field litellm exposes about a request — the user-facing model, the model actually dispatched to the provider, the deployment, and the caller's identity (team, key, end-user) — is parsed **once**, here, out of the ``StandardLoggingPayload`` (or a ``UserAPIKeyAuth`` at the auth boundary). Span data, baggage promotion, and the mappers then read these typed fields instead of each digging into the raw ``metadata`` / ``hidden_params`` dicts. Two models live here because a request's identity is known *before* its model resolution is: * :class:`RequestIdentity` — team / key / end-user, seeded into Baggage at the auth boundary (``from_user_api_key_auth``), before routing has picked a deployment. ``provider_model`` is therefore absent from that early seed and is only filled in from the payload once the call closes. * :class:`RequestContext` — the full picture available at close: the resolved request vs. provider model split, plus the response model, model group, model id, and api base, wrapping the :class:`RequestIdentity`. The request-vs-provider model split is the subtle part. On the proxy a caller asks for a *model group* (e.g. ``gpt-4o``) that routes to a concrete deployment (e.g. ``azure/my-deployment``); the two are distinct and both worth recording. ``StandardLoggingPayload`` exposes them as: * ``model_group`` — the user-facing name the caller requested. * ``model`` — already reconstructed (see ``reconstruct_model_name``) to the name litellm dispatched to the provider (the deployment, provider-prefixed). * ``hidden_params.litellm_model_name`` — a secondary source for the dispatched model (populated only on some call paths, e.g. files). So ``gen_ai.request.model`` is the *group* (falling back to the call model on the SDK path, which has no group), and ``litellm.provider.model`` is the *dispatched* model. They coincide on the SDK path, which is correct. ) annotations)IteratorMapping) dataclassfield)MappingProxyType) TYPE_CHECKINGAnyFinalcast)$LITELLM_LOGGING_NO_UPSTREAM_LLM_CALL)resolve_operation)as_str to_seconds)StandardLoggingPayloadT)frozenceZdZUdZded<dZded<dZded<dZded<dZded<dZ ded <dZ ded <e e Z d ed <eddZeddZy)RequestIdentityN str | Nonecall_idteam_id team_aliasMapping[str, Any] | None team_metadatakey_hashend_userprovider_model)default_factoryzMapping[str, str]metadatac :ttttf|j dxsi}|j Dcic]2\}}t |ttttfs'|t|4}}}|t|j dxst|j dt|j dxst|j dt|j dxst|j dt|j dt|j d t|j d xst|j d t|| Scc}}w) a Parse caller identity out of a closed request's payload metadata. ``provider_model`` is resolved here too (see :func:`resolve_provider_model`) so the identity carried into Baggage labels every span with the dispatched model, not just the user-facing one. rlitellm_call_ididuser_api_key_team_idruser_api_key_team_aliasruser_api_key_team_metadatauser_api_key_hashruser_api_key_end_user_id)rrrrrrrr) r rstrobjectgetitems isinstanceboolintfloatr_team_metadata_dictresolve_provider_model)clspayloadraw_metakeyvaluers m/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/litellm/integrations/otel/model/metadata.py from_payloadzRequestIdentity.from_payloadEsCwsF{3W[[5L5RPRS6>nn6Fu U*UZ]`bfhkmr\sJtCUOuu7;;'89:WfW[[QUEV>W8<<(>?@cF8<GKK 34hx||Lf?g8h1':  vs (F-Fc fd}dDcic]\}}||x}r |t|}}}|t|dt|dt|dt|dt|d|Scc}}w) uIdentity from a ``UserAPIKeyAuth`` (duck-typed to keep this module free of a proxy import). Used in the pre-call hook to seed Baggage early — before any LLM, guardrail, or service span is created — so the whole request's spans inherit identity, not just the LLM-call span. Metadata sub-keys use the ``user_api_key_*`` names that ``baggage.DEFAULT_BAGGAGE_METADATA_KEYS`` promotes. ct|dSN)getattr)nameauths r7z8RequestIdentity.from_user_api_key_auth..hs'$d";))user_api_key_user_iduser_id)user_api_key_org_idorg_id)user_api_key_alias key_alias)r' end_user_idrrrapi_keyrG)rrrrrr)r(rr0)r2r>r*meta_keyattrr6rs ` r7from_user_api_key_authz&RequestIdentity.from_user_api_key_auth]s<#  $ T"" c%j     3y>*c,/0-c/.BCC N+C ./    s B)r3rreturnr)r>r)rLr)__name__ __module__ __qualname__r__annotations__rrrrrrrdictr classmethodr8rKr@r7rr4sGZGZ!J !/3M+2HjHj"&NJ%"'"=H=  .  r@rcreZdZUdZded<ded<ded<ded<ded<d ed <edd Zedd Zy )RequestContexta@The fully-resolved view of a closed request, parsed once from the payload. ``request_model`` is the user-facing requested model and ``provider_model`` (on :attr:`identity`) is the model litellm dispatched to the provider; the two differ on the proxy (group vs. deployment) and coincide on the SDK path. r( request_modelrresponse_model model_groupmodel_idapi_baseridentityc.|jjS)z?The dispatched-model name, carried on the identity for Baggage.)r[r)selfs r7rzRequestContext.provider_models}}+++r@c 0ttttf|j dxsi}ttttf|j dxsi}|j d}ttttft |t r|ni}t|j dxst|j d}||xst|j dxsdt|j d|t|j dxst|j dt|j d xst|j d tj| S) Nr hidden_paramsresponserXmodelrY model_inforZ)rVrWrXrYrZr[) r rr(r)r*r,rQr_model_info_idrr8)r2r3r4hidden raw_responser`rXs r7from_standard_logging_payloadz,RequestContext.from_standard_logging_payloads7wsF{3W[[5L5RPRSWS&[17;;3O3USUV%kk*5 wsF{3ZP\^bEc\ikl#GKK $>?f6(,,WdJeCf &K G0D)EK!(,,w"78#GKK 34bx||T`Ga8bGKK 34Vvzz*?U8V$11':  r@N)rLr)r3rrLrU) rMrNrO__doc__rPpropertyrrRrgrSr@r7rUrUsS ,,  r@rUcteZdZUdZded<ded<ded<ded <d ed <d ed <d ed<ded<eddZy) LLMCallEventaAThe typed view of the live callback ``kwargs`` (``model_call_details``). litellm hands every callback an untyped ``kwargs`` god object. The fields the OTel logger needs out of it are parsed **once**, here, so the ``CustomLogger`` reads typed attributes instead of digging into the dict at each boundary. rrStandardLoggingPayload | Noner3r dynamic_paramsMapping[str, str] | None auth_metadatar-is_no_upstream_callupstream_startedr(provisional_span_name float | Nonetime_to_first_chunk_secondsc |jd}|r td|nd}tt|jd}t|jdxsd}|t ||||jdt ||t |jt|jddu|jd|jt| S) Nstandard_logging_objectr call_typerarb standard_callback_dynamic_paramsapi_call_start_time )rr3rmrorprqrrrt) r*r rr_call_idror-r r6striprt)r2kwargs raw_payloadr3 operationras r7 from_dictzLLMCallEvent.from_dicts#ZZ(AB HS6 DY],VFJJ{4K-LM fjj128bWf-!::&HI'8 $VZZ0T%U V#ZZ(=>dJ%.__$5Qug">"D"D"F(CF(K  r@N)r}Mapping[str, Any]rLrk)rMrNrOrhrPrRrrSr@r7rkrksW+*,+ !--  r@rkcttttf|j dxsi}|j dsyt |j d}t |j d}||y||z S)aSeconds from the upstream request being issued (``api_call_start_time``) to the first streamed chunk (``completion_start_time``); ``None`` for non-streaming calls, where ``completion_start_time`` is backfilled with the end time and would not measure first-chunk latency.optional_paramsstreamNrycompletion_start_time)r rr(r r*r)r}rapi_call_startcompletion_starts r7rtrts} "'#s("3VZZ@Q5R5XVXYO   x (&vzz2G'HIN(4K)LM!1!9 n ,,r@cBtfdt||DdS)uThe key/team config the proxy resolved at auth, or ``None`` off the proxy. Read from the payload once the call closes and from ``litellm_params`` at ``pre_call``, where no payload exists yet — the LLM-call span is *created* at ``pre_call``, so the tracer (and therefore the destination) must be resolvable there. Values arrive untyped, so non-string entries are dropped rather than passed on to header builders. c3ZK|]"}t|jdxr$yw)user_api_key_auth_metadataN)_string_entriesr*).0rtypeds r7 z auth_metadata..s3 (6R)STTT  (+N)next_metadata_dicts)r3r}rs @r7roros+  +GV<  r@c<t|tsytd|S)zBA read-only view of ``value`` when it is a mapping, else ``None``.NMapping[str, object])r,rr r6s r7_as_str_mappingr s eW % & ..r@c t|}|yt|jDcic]\}}t|ts||c}}}|xsdScc}}wr;)rrr+r,r()r6entriesr5itemrs r7rrsS$U+G# $i93S]^bdgShS$Y$ijE =D%js A A c#Kt|}| t|jd}||t|jdyfddDEd{y7w)aRequest metadata dicts, closed-call payload first then the live kwargs. ``litellm_metadata`` is the metadata field on the Anthropic-shaped routes; litellm copies it onto ``metadata``, but both are yielded so a route that populates only one is still covered. Nrlitellm_paramsc3ZK|]"}tj|x$ywr;rr*)rr5rparamss r7rz"_metadata_dicts..-s1 ' 38 8H E r)rlitellm_metadatar)r3r} payload_viewpayload_metadatarrs @@r7rrsn*'2L"1,2B2B:2N"O  '" "#FJJ/?$@AF ~3sAA&A$A&c|:t|jdxst|jd}|r|St|jdS)zLThe call id from the payload (when closed) or the bare kwargs (at pre_call).r!r")rr*)r3r}rs r7r{r{4sM ,= >?\6'++VZJ[C\ N &**./ 00r@cXt|trt|jdSy)zThe user-facing ``model`` from a pre-call ``data`` dict (``None`` if absent). Read at the auth boundary to label early Baggage before routing has resolved a deployment; ``data`` is duck-typed since it arrives untyped from the proxy. raNr,rrr*)datas r7model_from_request_datar=s% $ dhhw'(( r@cfttttf|j dxsi}ttttf|j dxsi}t |j dxs6t |j dxst |j dS)uoThe model litellm dispatched to the provider, from the payload. Prefers the explicit ``hidden_params.litellm_model_name`` (set on call paths that know it, e.g. files), then the top-level ``model`` — which ``reconstruct_model_name`` has already resolved to the deployment's provider-prefixed name. Returns ``None`` only when neither is present. rr_ deploymentlitellm_model_namera)r rr(r)r*r)r3r4res r7r1r1Hs73;/Z1H1NBOHf-w{{?/K/QrRF x||L)*vfVZZ@T5U.VvZ`ahalalmtauZvr@cXt|trt|jdSy)zFThe deployment id from a ``metadata.model_info`` sub-dict, if present.r"Nr)rcs r7rdrdYs#*g&jnnT*++ r@c>t|tr |r t|Sy)a0The team's free-form metadata as a raw mapping, or ``None`` when missing or empty. Carried raw on the identity and filtered to an operator allowlist only at Baggage-promotion time (see ``baggage.promoted_baggage``), so an empty case is dropped rather than carrying a useless ``{}``. N)r,rrQrs r7r0r0`s%!eE{ r@N)r}rrLrs)r3rlr}rrLrn)r6r)rLzMapping[str, object] | None)r6r)rLrn)r3rlr}rrLzIterator[Mapping[str, object]])r3rlr}rrLr)rr)rLr)r3rrLr)rcr)rLr)r6r)rLr)&rh __future__rcollections.abcrr dataclassesrrtypesrtypingr r r r litellm.constantsr 'litellm.integrations.otel.model.semconvr%litellm.integrations.otel.model.utilsrrlitellm.types.utilsrrrUrkrtrorrrr{rr1rdr0rSr@r7rs"H#-("22BED: $G G G T $% % % b $6 6 6 r -&/ *4H#01" r@