tPjHUdZddlZddlZddlZddlZddlZddlmZddlm Z m Z m Z ddl m Z ddlmZddlmZmZmZmZmZmZddlZddlmZmZdd lmZdd lmZdd lm Z m!Z!dd l"m#Z#dd l$m%Z%ddl&m'Z'ddl(m)Z)m*Z*ddl+m,Z,ddl-m.Z.m/Z/m0Z0m1Z1m2Z2er ddl3m4Z5ddl6m7Z7dZ8ee9d<dZ:ee9d<dZ;ee9d<dZee e?efe9d<Gdd eZ@Gd!d"ed#$ZAGd%d&ed#$ZBGd'd(eCZDe Gd)d*ZEGd+d,e eZFy)-zGRubrik LiteLLM Plugin for prompt/response moderation and batch logging.N)Counter) AwaitableMappingSequence) dataclass)MappingProxyType) TYPE_CHECKINGAnyFinalLiteralOptional TypedDict)NeverReadOnly)verbose_logger)CustomBatchLogger)CustomGuardrailModifyResponseException)safe_deep_copy)ModelParamHelper)convert_content_list_to_str)get_async_httpx_clienthttpxSpecialProvider)GuardrailEventHooks)ChatCompletionMessageToolCallFunctionGenericGuardrailAPIInputsStandardLoggingPayload!StandardLoggingUserAPIKeyMetadata)Logging)UserAPIKeyAuthz/v1/after_completion/openai/v1!_WEBHOOK_PATH_RESPONSE_MODERATIONz/v1/before_prompt/openai/v1_WEBHOOK_PATH_PROMPT_MODERATIONz/v1/litellm/batch_WEBHOOK_PATH_LOGGING_BATCHi'_MAX_QUEUE_SIZEgN@_DROP_WARNING_INTERVAL_SECONDS_EMPTY_MAPPINGceZdZUeeed<y)_ServiceToolCallidN)__name__ __module__ __qualname__rstr__annotations__`/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/litellm/integrations/rubrik.pyr)r)7s  r1r)c4eZdZUeeed<eeeed<y)_ServiceMessagecontent tool_callsN)r+r,r-rr.r/rr)r0r1r2r4r4;s c]"2344r1r4F)totalceZdZUeeed<y)_ServiceChoicemessageN)r+r,r-rr4r/r0r1r2r9r9@s o &&r1r9ceZdZdZy)#_MalformedToolBlockingResponseErroraRaised when the response moderation service returns a structurally invalid response (e.g. empty ``choices``). Distinct from transient network/HTTP errors so callers can surface a louder, misconfiguration-style log instead of treating it as a routine fail-open. N)r+r,r-__doc__r0r1r2r<r<Dsr1r<ceZdZUdZeed<y)BlockedResponseResultzReturned by _extract_response_block when the response was blocked (response text replaced, or at least one tool call removed). explanationN)r+r,r-r=r.r/r0r1r2r?r?NsDr1r?c eZdZ dVdedzdedzffd ZedeefdZdWdZ dWdZ d eddfd Z de jddzfd ZdWd Zd Z dXdedededdeddef dZedeedededefdZdedededdefdZdedededdefdZededdeddfdZedeedeedffdZ ede!defdZ"ed eedzdefd!Z#edeed"ed#edzde$eeffd$Z%ed%eedzdee$ee!fdffd&Z&ed'e$ee!fdeedffd(Z'edede$eefde$eeffd)Z(ed*e$ee!fde$eefdzde$eeffd+Z)ed,edefd-Z*ede$eefd*e$eefdefd.Z+edXd*e$eefde$eefdzdedzfd/Z,ed0eeefd1e$eefddfd2Z-ed0eeefd1e$eefddfd3Z.d4e$eefd5ede/dzfd6Z0dWd7Z1dWd8Z2d4e$eefd5efd9Z3d:Z4d;Z5 dXdedd?edzddf d@Z7dddAdBdCedzd=d>ddf dDZ8dddAdBd=d>de/fdEZ9ed=d>de:fdFZ;ed*e$ee!fd=d>deeeffdGZdJZ?dKed0e$eefdLede$ee!ffdMZ@dNe$eefde$eefde$ee!ffdOZAd0e$eefde$ee!ffdPZBedQe$ee!fdedzfdRZCedQe$ee!fdSeedTedeDdzfdUZExZFS)Y RubrikLoggerNapi_keyapi_basec tj|_|jdd|j dxst j |d<|j dd|d<t| d|jt|jd|tjdd|_ d|_|j|xst!j"d |_|j$stj&d |j)t*|_d |_d |_|xst!j"d }|s t3d|j5dj7d}|j9|t;|j$rdd|j$dnddi|_|j?|_ y)Nguardrail_namerubrik event_hook default_onF) flush_locksupported_event_hookszinitializing rubrik loggerTRUBRIK_API_KEYz@Rubrik: No API key configured. Requests will be unauthenticated.rRUBRIK_WEBHOOK_URLzKRubrik webhook URL not configured. Set RUBRIK_WEBHOOK_URL or pass api_base./z/v1zapplication/jsonzBearer ) Content-Type AuthorizationrPr0)!asyncioLockrJ setdefaultgetr post_callsuper__init__listget_supported_event_hooksrdebugstreaming_end_of_stream_only streaming_buffer_until_moderated_parse_sampling_rateosgetenvkeywarning_parse_batch_sizer%max_queue_size_dropped_since_warning_last_drop_warning_time ValueErrorrstrip removesuffix_setup_clientsr_headers_start_periodic_flush_task_periodic_flush_task)selfrCrDkwargs _webhook_url __class__s r2rXzRubrikLogger.__init__Ws ",,.*H5 &zz,7X;N;X;X| ::l # +#(F<   "&t'E'E'G"H  9:-1)15- !!#9bii(89xx  " "#e f  .&'#'*$B299-A#B jk k#**3/< 0, using defaultz,Invalid RUBRIK_BATCH_SIZE: %r, using default)r_r`intrrb batch_sizerg)rn _batch_size parsed_sizes r2rczRubrikLogger._parse_batch_sizesoYY':;  d%(%5 !#"**+\^ij&1DO  d&&'UWbc ds&A A A+*A+ webhook_urlc |t|_|t|_|t|_t tj|_ t tjdtjddi|_ y)N) llm_providertimeoutg@g@)connect)rparams) r"response_moderation_endpointr#prompt_moderation_endpointr$logging_endpointrrLoggingCallbackasync_httpx_clienthttpxTimeoutmoderation_client)rnrs r2rjzRubrikLogger._setup_clientssx/:m<];^,_)-8M:Y9Z*['#.-0K/L M"8FZFjFj"k!7-==u}}S#>?" r1c tj}|j|j S#t$rYywxYw)zIStart the periodic flush task only when an event loop is already running.N)rRget_running_loop RuntimeError create_taskperiodic_flush)rnloops r2rlz'RubrikLogger._start_periodic_flush_tasksE !224D 3 3 566  s5 AAc||j|jjr|j|_yyN)rmdonerlrns r2_ensure_periodic_flush_taskz(RubrikLogger._ensure_periodic_flush_tasks6  $ $ ,0I0I0N0N0P(,(G(G(ID %1Qr1cLKt|dd}||jyyw)aCancel the periodic flush task. ``moderation_client`` and ``async_httpx_client`` are shared objects from LiteLLM's global HTTP-client cache (``get_async_httpx_client`` uses the same cache key for all instances with equal parameters). Closing them here would close the shared connection pool for every other logger instance; let LiteLLM manage their lifecycle instead. rmN)getattrcancel)rntasks r2aclosezRubrikLogger.acloses,29?UW[1\   KKM s"$inputs request_data input_typerequestresponse logging_objLiteLLMLoggingObjcK|dk(r,|j|j||||dd{S|dk(r,|j|j||||dd{S|S777w)a{Moderate prompts (request) and responses (response); fail-open. - ``request``: evaluate the prompt via the before_prompt webhook and block disallowed prompts before the model is called. - ``response``: evaluate the assistant's response text and tool calls via the after_completion webhook and block on a policy violation. litellm's guardrail-translation layer normalizes Anthropic and OpenAI requests/responses into ``inputs`` before this runs, so a single code path covers both wire formats. The configured guardrail ``mode`` selects which surface(s) run. rzPrompt moderationNrzResponse moderation)_guarded_moderate_prompt_moderate_response)rnrrrrs r2apply_guardrailzRubrikLogger.apply_guardrails&  "%%flKH#   #'' kJ%    s!-A+A'0A+ A)!A+)A+corolabelcK |d{S7#t$rt$r$}tjd|d|cYd}~Sd}~wt$r%}tj d||d|cYd}~Sd}~wwxYww)zAwait a moderation coroutine fail-open: re-raise an intentional block, log at critical for malformed service responses, and swallow any other error returning ``inputs`` unchanged.NzResponse moderation service returned a malformed response: %s. Requests are NOT being checked -- verify the webhook configuration. Returning original inputs unchanged.Texc_infoz8%s hook failed: %s. Returning original inputs unchanged.)rr<rcritical Exceptionerror)rrres r2rzRubrikLogger._guarded s~ : :&  2   # #F  M   J   M sRA5A5A2AA2A5 A2 A-'A2(A5-A22A5clK|jd}|jd}|s|s|S|j|xsd}|j|}|rt|dtnt}|r|st j d|j||} |j||| } |j||} |j| | d{} |j| ||} | rG|j||}|j||t| j|||j |S7bw)zSend response text + tool calls to the after_completion webhook and raise if either the response text or any tool call is blocked.r6textsr0model_call_detailsz^Rubrik: logging_obj present but model_call_details is empty -- request context will be missingNr:modelrrF)rU_normalize_tool_calls _join_textsrr'rrb_correlation_id"_build_response_moderation_payload_extract_request_data%_post_to_response_moderation_endpoint_extract_response_block_resolve_model_stash_block_contextrr@rF)rnrrrr6rmessage_tool_calls sent_content call_details request_id response_datareq_dataservice_responseblockedrs r2rzRubrikLogger._moderate_response/sA#JJ|4 zz'*%M$($>$>z?OR$P"..u5 U`w{,@.Qft |  " "p !00|L #FFGY[gist 44\<P(,(R(RS`bj(k"k556FHZ\hi ..|\JE  % %k< @)++)#22   #lsC D4D2A#D4cK|jd}|s3|jd}|r djd|D}|rd|dg}|s|S|j||}|j|d{}|j |} | |S|jdxs|jdxsd } |j ||t | | ||j 7lw) zeSend the (normalized) prompt to the before_prompt webhook and raise if the prompt is blocked.structured_messagesr c3&K|] }|s| ywrr0.0ts r2 z0RubrikLogger._moderate_prompt..ls)@a!)@userroler5Nrunknownr)rUjoin _build_prompt_moderation_payload#_post_to_prompt_moderation_endpoint_extract_prompt_refusalrrrF) rnrrrmessagesrjoinedpayloadrrefusalrs r2rzRubrikLogger._moderate_prompt]s::34"::g.E $ )@U)@ @)/F CDHM>>v|T(,(P(PQX(Y"Y556FG ?Mzz'*Tl.>.>w.GT9 !!+|<%%..   #ZsA1C"3C 4A-C"c|+tjd|jdd|d<yd|jd<||d<y)aStash signals so the deferred success-event skips this request and ``async_post_call_failure_hook`` can build the failure payload. - Sets a flag on ``logging_obj.model_call_details`` so the deferred success-event handler short-circuits. - Stashes a reference to ``logging_obj`` on ``request_data`` under a custom key. ``ProxyLogging.post_call_failure_hook`` pops only ``litellm_logging_obj`` before iterating callbacks, so this key survives. When ``logging_obj`` is ``None`` the success-event has no way to observe the block (the flag has nowhere to live), so we log an error instead of silently dropping the signal. NzRubrik: moderation block fired with logging_obj=None for litellm_call_id=%s; cannot suppress success event or attach failure payload.litellm_call_id_rubrik_logging_objT_rubrik_blocked)rrrUr)rrs r2rz!RubrikLogger._stash_block_contexts[&    K  !23   37L. / <@ &&'89.9 *+r1r6.c&td|DS)zHConvert tool_calls from inputs to ChatCompletionMessageToolCall objects.c3FK|]}tj|ywr)rB_normalize_tool_callrtcs r2rz5RubrikLogger._normalize_tool_calls..sPr\66r:Ps!tuple)r6s r2rz"RubrikLogger._normalize_tool_callssPZPPPr1rc  t|tr|St|trr|jdxst}t|jdd|jddt |jdd|jddSt |drAt |dr5t|jxsdt|ddxsd|jStd t|jd |) Nfunctionr*typename arguments)rr)r*rrz#Cannot normalize tool_call of type : ) isinstancerdictrUr'rhasattrr*rr TypeErrorrr+)rfuncs r2rz!RubrikLogger._normalize_tool_calls b7 8I b$ &&,>D066$#VVFJ/!&"-"hh{B7  2t Z!8055;BR.<*  =d2h>O>O=PPRSURXYZZr1rc8|sydjd|DS)zJoin response text segments into the single content string the webhook evaluates. Empty when there is no assistant text.rrc3&K|] }|s| ywrr0rs r2rz+RubrikLogger._join_texts..s/qQ/r)r)rs r2rzRubrikLogger._join_textssyy/E///r1r5rcd|xsdd}|rtd|D|d<|xsdtjdtt jdd ||rdnd d gd S) aBuild an OpenAI ChatCompletion-format dict (assistant text + tool calls) for the after_completion webhook. ``content`` is sent so the webhook can moderate the response text; ``None`` when the assistant produced no text (tool-call-only response). assistantNrc3@K|]}|jdyw)T) exclude_noneN) model_dumprs r2rzBRubrikLogger._build_response_moderation_payload..s)`r"--T-*J)`sr6 chatcmpl-zchat.completionrrstop)indexr: finish_reason)r*objectcreatedrchoices)ruuiduuid4rtime)r6r5rr:s r2rz/RubrikLogger._build_response_moderation_payloads| $-  $))`U_)`$`GL !:)DJJL> :'499;'&5?\V  r1rc.td|xsdDS)aKCollapse each message's content to a plain string for the webhook. litellm normalizes Anthropic ``/v1/messages`` requests to OpenAI shape, but a turn sent as content-parts (``[{"type": "text", ...}]``) stays a list. The before_prompt webhook reads ``content`` as a string and drops non-string content, so we flatten text parts here (images skipped, per ``convert_content_list_to_str``) -- otherwise block-content prompts would pass through unmoderated. Builds a new list; never mutates the shared ``structured_messages``. c3K|]Q}t|tr?|jddjdtj |DdSyw)rrc3&K|] }|s| ywrr0)rps r2rzJRubrikLogger._flatten_messages_for_moderation...s$b1`aQ$brrN)rrrUrrB_moderation_text_parts)rr:s r2rz@RubrikLogger._flatten_messages_for_moderation..sP '4(  F+99$b 0S0ST[0\$bb  sAAr0r)rs r2 _flatten_messages_for_moderationz-RubrikLogger._flatten_messages_for_moderations$ $>r    r1r:c|jd}t|gd|jdxsdDtt|tr|jdndxsdS)zEvery attacker-controlled text segment of a message: its content plus the arguments of any tool call or deprecated function call. function_callc3K|]I}t|tr7t|jdxstjdxsdKyw)rrrN)rrr.rUr'rs r2rz6RubrikLogger._moderation_text_parts..sEb$'RVVJ'9>>>{KQrRsAAr6r0rNr)rUrr.rr)r:fcs r2rz#RubrikLogger._moderation_text_partssnKK0 ( 0  !++l39r    2t(< $$M2 N  r1cV|jdxs|jdxsdtj|jdd}|jd}|||d<|jd}|r||d<|jdxs|jd}|r||d<|S) aBuild the bare OpenAI request the before_prompt webhook consumes. Unlike the after_completion envelope, this endpoint takes a raw OpenAI chat-completions request. ``structured_messages`` is litellm's OpenAI-normalized view of the prompt, so this works for Anthropic ``/v1/messages`` requests too. Optional fields are sent only when present so the payload stays clean. rrr)rrtoolsrcorrelation_keyr)rUrBr)rrrrrrs r2rz-RubrikLogger._build_prompt_moderation_payloadsZZ(KL,<,$BUBU U )--.CTJ    " "'   !23  )!))*,Q R"&&'@A  )7)=G  6  !23   22X  ##G\:r1c0ddlm}|j|S)aIdentify the caller whose request was blocked. Uses the same mapper the success path and the proxy spend logger use, so a block log and a success log agree on the caller key set. The import is deferred because ``litellm/integrations/`` is SDK-side while the mapper lives under ``proxy/``: ``rubrik.py`` is imported during guardrail discovery and must not pull proxy-only dependencies into its import chain. It is unguarded because the only dispatcher of this hook, ``ProxyLogging.post_call_failure_hook``, already imports fastapi at module scope, so there is no path where this hook runs and the mapper is missing. r)LiteLLMProxyRequestSetup)$litellm.proxy.litellm_pre_call_utilsr^'get_sanitized_user_information_from_key)rKr^s r2_caller_metadatazRubrikLogger._caller_metadatas R'OOPabbr1c j|jd}||jnd}|jd|jdxsd|jdxsddtj|jdxst||||jdxsd|j |dd S) NrDrrrrrr0rH) r*r model_groupmodel_idmodel_parameters startTimeendTimecompletionStartTimermetadatastatus)rU timestampr%get_standard_logging_model_parametersr'ra)rurrK _raw_start_starts r2rZz$RubrikLogger._build_fallback_payloads),,\: 2<2H ,,.d""#45!%%g.4"(++G4: 0 V V  !23E~! #)$((4:,,->?!  r1cK |jj|j||jd{}|j y7#t j $rE}tjd|jj|jjd}~wt$rtjdwxYww)N)rjsonheaderszRubrik HTTP Error: %s - %szRubrik Layer Error) rpostrrkraise_for_statusrHTTPStatusErrorrrSr status_codetextr)rndatarrs r2_log_batch_to_rubrikz!RubrikLogger._log_batch_to_rubriks $($;$;$@$@)) %A%H  % % '  $$   $ $%A1::CYCY[\[e[e[j[j k    $ $%9 :  s9C 5AAAC AC$AB$$#CC crK|jsy|j|jd{y7w)a@Handles sending batches of responses to Rubrik. Note: the canonical flush path is :meth:`flush_queue`, which takes a single snapshot used for both sending and queue draining. This method is kept for direct callers / tests; it intentionally does NOT remove events from the queue. Nrw)r4rxrs r2async_send_batchzRubrikLogger.async_send_batchs6~~ ''(   s -757c&K|jy|j4d{|js dddd{yt|j}tjdt | |j |d{|jdt |=tj|_ dddd{y777J#t$rYdddd{7ywxYw7+#1d{7swYyxYww)aSnapshot, send, and drain in one consistent step. Overrides the base implementation so the same snapshot drives both the HTTP send and the queue truncation. This avoids the subtle coupling where the base class captures ``len(self.log_queue)`` separately from the snapshot taken inside ``async_send_batch``, which could otherwise drift in a future refactor and cause duplicate deliveries to Rubrik. Nz#Rubrik: Flushing batch of %s eventsrz) rJr4rYrr[r7rxrr last_flush_time)rnsnapshots r2r8zRubrikLogger.flush_queues ?? " ?? / />> / / /#4>>2H  !FH V //X/>>> X/#'99;D  / / / / ?  / / /  / / / /sDCDC< DCD4C<8C CC1C< DC:DDC C7#C<$ D/C20D6C77C<:D<DD D Dendpoint service_namecHKtjd|||jj|||jd{}|j |j }t|ts$t|dt|jd|S7Zw)zPOST ``payload`` to a Rubrik webhook and return its dict response. Raises: Exception: If the service is unavailable or returns an error. TypeError: If the response JSON is not a dict. zSending request to %s: %s)rprqNz returned non-dict JSON (z9); expected OpenAI chat completion shape or empty object.) rr[rrrrkrsrprrrrr+)rnrrr http_responseresults r2 _post_jsonzRubrikLogger._post_jsons 8,Q%)%;%;%@%@ MM&A&  &&( - 2 2 4&$'.!L))*+))    sAB"B AB"rcbK||d}|j|j|dd{S7w)azPost the ``{request, response}`` envelope to the after_completion webhook and return its (possibly rewritten) response. Args: response_data: The OpenAI-formatted response payload to send. request_data: Original LLM request data to include alongside the response for additional context. Empty dict if unavailable. rzResponse moderation serviceN)rr)rnrrenvelopes r2rz2RubrikLogger._post_to_response_moderation_endpoints<'3 N__  - -  )    s &/-/cXK|j|j|dd{S7w)zPost a bare OpenAI request to the before_prompt webhook. Returns ``{}`` (passthrough) or a synthetic chat.completion (block). zPrompt moderation serviceN)rrr9s r2rz0RubrikLogger._post_to_prompt_moderation_endpoint#s( __T%D%DgOjkkkks !*(*rc|jd}|sy|djdxst}|jd}|xsdS)zReturn the refusal text when the prompt was blocked, else None. The before_prompt webhook returns ``{}`` (passthrough) or a synthetic chat.completion whose ``choices[0].message.content`` is the refusal explanation. rNrr:r5zRequest blocked by policy.r#)rrr:r5s r2rz$RubrikLogger._extract_prompt_refusal*sL;K:N:Ny:Y  2Dn Y/666r1all_tool_callsrc |jdxsd}|s td|djdxst}|jdxsd}|jdxsd}td |D td |D}t |t |kxs#t fd |j D }t|xr|j|d } t|xr ||k7xr| } | rt|xsd S|r2| r|t |djd} n|} t| xsdSy)aDetect whether the webhook moderated the response text or tool calls. The after_completion webhook rewrites the response in place with no explicit "blocked" flag, so we infer a block by diffing what we sent against what came back: - Tool block: a tool call we sent is absent from the returned (allowed) set. - Text block: the returned content was REPLACED wholesale (a text violation), as opposed to having a tool-block explanation APPENDED to the original content. We tell them apart with ``startswith``, which mirrors the webhook's own append-vs-replace behavior. Returns None when nothing was moderated. A text block supersedes a tool block (mirroring the webhook, which drops tool calls on a text block). Expects service_response in OpenAI chat completion format: {"choices": [{"message": {"tool_calls": [...], "content": "..."}}]} rr0z3Response moderation service returned empty responserr:r6r5rc3JK|]}|jds|dyw)r*NrUrs r2rz7RubrikLogger._extract_response_block..^s#9qrdfdjdjkodp"T(9qs# #c3NK|]}|js|jywr)r*rs r2rz7RubrikLogger._extract_response_block.._s9bB\^\a\a"%%9bs%%c3NK|]\}}j|d|k\yw)rNr)rtc_idcountreturned_id_countss r2rz7RubrikLogger._extract_response_block..cs/Y :F%  " "5! , 5Y s"%z zResponse blocked by policy.)r@NrzTool call blocked by policy.) rUr<r'rr7allitemsbool startswithr?lstrip) rrrrr:returned_tool_callsreturned_contentrequired_id_counts tools_blockedappended text_blockedr@rs @r2rz$RubrikLogger._extract_response_block9si24D3G3G 3R3XVX56kl l  2Dn%,[[%>%D"")++i"8">B 3:9qM`9q2q299b.9b2b ##67#n:MM UXY J\JbJbJdY V R |,c1A1L1LP\~]aMb1c"<0f5E5Uf^fZf (5E5fIfg g /s,E7J (6: )12  12  # B 12 )   #  D,),,12 , # ,\" )" " 12 " # " H:12:: ::<Q(6*:QuEbdgEg?hQQ[[)F[[*08C=4/0C00 :;  $J  f    > 8F3Cd3J uU\]`be]eUfhkUkOl  (  S(9  eCHo    )c6k* f B# c3h'# c6k*T1#  f # # JlVlll4WS&[%94QTVYQYIZ4_b44 ngc3h&7 nwsTWxGX[_G_ nknquku n n'Df,='wsTWxGX']a''&S&[(973PV;CW\`8(c6k*(8;( $ &( %/$ wsF{/C QT  99%) ,o,o&,o, ,o Tz ,o  ,o\#(#-#t # , #  #JE(E-E, E ENc,<cAbcc$ c3h' ,  c6k    <$  /:wsF{7K[^cjknpsksct. sF{+ c6k*  c   (lfAUlZabegjbjZkl 7'#s(2C 7d 7 7E!#s(+E !>?EE  % EEr1rB)Gr=rRr_r0r r  collectionsrcollections.abcrrr dataclassesrtypesrtypingr r r r r rrtyping_extensionsrrlitellm._loggingr(litellm.integrations.custom_batch_loggerr%litellm.integrations.custom_guardrailrr'litellm.litellm_core_utils.core_helpersr-litellm.litellm_core_utils.model_param_helperr8litellm.litellm_core_utils.prompt_templates.common_utilsr&litellm.llms.custom_httpx.http_handlerrrlitellm.types.guardrailsrlitellm.types.utilsrrrrr*litellm.litellm_core_utils.litellm_loggingr rlitellm.proxy._typesr!r"r/r#r$r%r&r'r.r)r4r9rr<r?rBr0r1r2rsM 88!"JJ -+FCJ94+K!5K)FF%8U8(,,-=b-Agc5j)*Ay5iu5 'Ye')  i?$5ir1