uPj5 UdZddlZddlZddlZddlZddlmZmZmZm Z m Z m Z ddl m Z mZmZmZmZddlmZddlZddlmZmZddlmZddlmZdd lmZdd lmZdd l m!Z!dd l"m#Z#dd l$m%Z%ddl&m'Z'ddl(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0e rddl1m2Z3ddl4m5Z5ddl(m6Z6neZ3edZ7ddl8m9Z9ddl:m;Z;GddeZ<eZ=ee>d<de?e@eAfde?e@eAffdZBde?deCfdZDde?e@eAfdeCfdZEd d!de e@eAffd"ZFeGZHeeGd#e>d$<d%e gedfddfd&ZId%e gedfdd#fd'ZJde e@efde@dzfd(ZKGd)d*ZL d/d+e d,eMeAd-fdzde?e@eAffd.ZNy)0a This contains LLMCachingHandler This exposes two methods: - async_get_cache - async_set_cache This file is a wrapper around caching.py This class is used to handle caching logic specific for LLM API requests (completion / embedding / text_completion / transcription etc) It utilizes the (RedisCache, s3Cache, RedisSemanticCache, QdrantSemanticCache, InMemoryCache, DiskCache) based on what the user has setup In each method it will call the appropriate method from caching.py N)AsyncGenerator AsyncIterator AwaitableCallable GeneratorMapping) TYPE_CHECKINGAnyFinalOptionalTypeVar) BaseModel) print_verboseverbose_logger) InMemoryCache)S3Cache)*CACHE_WRITE_SHUTDOWN_FLUSH_TIMEOUT_SECONDS)update_response_metadata)1_assemble_complete_response_from_streaming_chunks)CachedEmbedding)ResponsesAPIResponse)RerankResponse)CachingDetails CallTypes EmbeddingEmbeddingResponse ModelResponseTextCompletionResponseTranscriptionResponseUsage)Logging"AnthropicMessagesStreamCacheWriterPromptTokensDetailsWrapper_StreamResultT!_get_parent_otel_span_from_kwargs)CustomStreamWrappercHeZdZUdZdZedzed<dZedzed<dZ e ed<y)CachingHandlerResponsea This is the response object for the caching handler. We need to separate embedding cached responses and (completion / text_completion / transcription) cached responses For embeddings there can be a cache hit for some of the inputs in the list and a cache miss for others N cached_resultfinal_embedding_cached_responseF embedding_all_elements_cache_hit) __name__ __module__ __qualname____doc__r,r __annotations__r-rr.boold/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/litellm/caching/caching_handler.pyr+r+Es3 !%M3:$@D#%6%=D-2$d2r6r+in_memory_cache_objrequest_kwargsreturncnd|vr|S|jDcic]\}}|dk7s ||c}}Scc}}w)a The caching handler is stored on the Logging object (``logging_obj._llm_caching_handler``), so keeping ``litellm_logging_obj`` inside ``request_kwargs`` closes a reference cycle (Logging -> LLMCachingHandler -> kwargs -> Logging) that keeps the full request payload (messages included) alive until a generational GC pass instead of being freed by refcount when the request ends. Nothing in the caching layer reads the logging object from these kwargs; cache-key generation ignores litellm-internal params. litellm_logging_obj)items)r9kvs r7_drop_logging_obj_from_kwargsr@Ts?N2+113 RTQqRead the caller-supplied ``cache_key`` off the request kwargs. cache_keyNrP)r9s r7_request_cache_keyrns   k4 00r6c$eZdZdedeeefdejfdZ d4dedede dejded eee fd e ed fdzd e dzfd Z d4dedede dejded eee fd e ed fdzd e fdZd eeefd eefdZdee eefd edzfdZdedzdeedzd eee fde dejded e edzeffdZdeded efdZdeddedd edfdZde dedejdejd ef dZde de dejdejd ef d!Zded eeefd e ed fd e dzfd"Z d4de ded eeefde ded e ed fd#edzd eezeze ze!ze"zdzfd$Z#de dede ded e"f d%Z$ d4d&e ded eee fd e ed fdzfd'Z% d4d&e d eeefd e ed fdzfd(Z&ded eee fd efd)Z'd&e(ded d*fd+Z)ded efd,Z*d-efd.Z+d-efd/Z, d5de ded eee fde d0ed1ed#edzd2e-dzfd3Z.y)6LLMCachingHandleroriginal_functionr9 start_timecHddlm}m}g|_g|_t ||_d|_||_||_ tjPttjj|r,|tjjt|_yd|_y)Nr) DualCache RedisCache) redis_cachein_memory_cache)litellm.cachingrtruasync_streaming_chunkssync_streaming_chunksr@r9preset_cache_keyrqrrlitellmcacherGr8 dual_cache)selfrqr9rrrtrus r7__init__zLLMCachingHandler.__init__s} :;=#:<";NK,0!2$ == $GMM4G4G)T09#MM// 31DO #DOr6Nmodel logging_obj call_typerMargs.r:c K|jddtj|jdddur |jdijdddur|xsd}d}d} d} |j}t j } d} t |} | |d<tjn|j| r[tjd |j||| d{} t j } | t| tsttjd d}tjj}tj||jd d|jdd|jdd\}}}}| | z dz}|j!|||| d|||j"}|j%| |||||jd d|} t'|s|j)|| ||||j*xsF|j,jdxs)tjj.di|j,}t1| dr|| j2d<t5| S|t6j8j:k(rq| ot| tr_tjOttjjt<s'|j?|| ||||\}} t5|| Stjd| t5| |Sy7Sw)aC Internal method to get from the cache. Handles different call types (embeddings, chat/completions, text_completion, transcription) and accordingly returns the cached response Args: model: str: original_function: Callable: logging_obj: LiteLLMLoggingObj: start_time: datetime.datetime: call_type: str: kwargs: Dict[str, Any]: args: Optional[Tuple[Any, ...]] = None: Returns: CachingHandlerResponse: Raises: None cachingNFTr}zno-cacher5parent_otel_spanrqzChecking Async Cache)rrMrz Cache Hit!custom_llm_providerapi_baseapi_keyrrrr)rrrMr,is_asyncrcache_duration_msr,rrMrrrrrQrr,rrend_time cache_hitrm_hidden_paramsr,)r-r,rMrrrr)r-r.zCACHE RESULT: %s)r,r-) rFr|r}copytime perf_counterr( _is_call_type_supported_by_cacherdebug_retrieve_from_cacherGlistdatetimenowget_llm_provider'_update_litellm_logging_obj_environmentr/(_convert_cached_result_to_model_responserR!_async_log_cache_hit_on_callbacksr{r9 get_cache_keyrWrr+r aembeddingvaluer(_process_async_embedding_cached_response)rrrqrrrrrMrr-r.r,cache_check_start_timecache_check_end_timerrrr_rrms r7_async_get_cachez"LLMCachingHandler._async_get_cachesg@ZZ 4 ( 0W]]5NSYS]S]^ginSoswSw JJw # ' ' E :$ F:2DHL +5: ,(,M[[]F-1,=,=,? "15 &G&O )9F% &}}(T-R-Rev-R-w$$%;<&*&?&?'!'@'! (,'8'8':$ ,Z t5T"((6'+I&.&7&7&;&;&=H7>7O7O#,2JJ7Ld,S!'J!= & 9d ; 84E.1 1EG]0]ae/e%@@$/#%&3!%,?*;A!2 : :I$($Q$Q&3"+%$/#,2JJ7Ld,S!%R%MGfU>>(3*7'1%-&/ ?--N..22;?N"==66M9L9LM }.>?DM 44[A1 NN!5!5!;!;;%1"=$7 1&w}}':':GD EE8W&3%$/#-# F7828W9Y  !3] C)+0O  k!sC/M1M2IMc d}tjJ|j|r7|xsd}|j} | j t |j || jd| jdd| jddur&d| vr"tjjdi| | d<t| |_ tdtjjdi| }|cd|vrn]|j}|j||||||jd d| }d} t j j#} tj$|xsd |jd d|jd d|jd d\}} } }|j'|| d|||dt)|s|j+||| | |j,xsF|jjdxs)tjjdi|j}t/|dr||j0d<t3|St3|S)Nrr5metadatarOTrmzChecking Sync Cachedetailrrrrr/F)rrrMr,rrQresultrrrrrr)r|r}rrupdateconvert_args_to_kwargsrqrFpoprr@r9r get_cacher/rrrrrrR-handle_sync_success_callbacks_for_async_callsr{rWrr+)rrrqrrrrrMrr, new_kwargsrrrdynamic_api_keyrrms r7_sync_get_cachez!LLMCachingHandler._sync_get_cache>sw%)  == $)N)Nar)N)s:2D & J   &**  ~~j)1z40~~h'4/Kz4Q*1--*E*E*S *S ;'"? "KD  / 0#MM33AjAM(}, 1 : :I$($Q$Q&3"+%$/#,2JJ7Ld,S!%R%M(,I&.&7&7&;&;&=H  00#kr,2JJ7Ld,S!'J!= & 9d ;  +' @@$/!4 5Qug>%&3!& AGfU#QQ#0'1%-&/ R--N..22;?N"==66M9L9LM }.>?DM 44[A1 NN%MBBr6czt|dtr|dgSt|dtr|dStd)zO Handles the input of kwargs['input'] being a list or a string input input must be a string or a list)rGrHr ValueError)rrMs r7handle_kwargs_input_list_or_strz1LLMCachingHandler.handle_kwargs_input_list_or_strsC fWos +7O$ $ w .'? "?@ @r6 non_null_listcj|D].\}}t|ts|jds)|dcSy)a  Helper method to extract the model name from cached results. Args: non_null_list: List of (idx, cr) tuples where cr is the cached result dict Returns: Optional[str]: The model name if found, None otherwise rN)rGdictrF)rrrcrs r7"_extract_model_from_cached_resultsz4LLMCachingHandler._extract_model_from_cached_resultss:# #EAr"d#w'{" #r6r-r,c d}g}g} |j|} t|D]/\} } | |j| | | j| | f1||d<t| dkDr]|j | } | s|j d} t | dgt| z}d|jd<d}d}| D]}|\} } |  | j d }|t|| d |j| <| j d }|||z }n)t| | trdd l m }||| | d z }| j d}|s|i}|jD]9\}}t|tt fr|j |d|z||<5|||<;ddlm}d}|r |di|}t)|d||}||_t|dk(rd}d}t,j,j/}t1j2||j dd|j dd|j dd\}}}}|j5||||dd||j7|||||||fS||fS#t&$rd}YwxYw)a Returns the final embedding cached response and a boolean indicating if all elements in the list have a cache hit For embedding responses, there can be a cache hit for some of the inputs in the list and a cache miss for others This function processes the cached embedding responses and returns the final embedding cached response and a boolean indicating if all elements in the list have a cache hit Args: final_embedding_cached_response: Optional[EmbeddingResponse]: cached_result: List[Optional[Dict[str, Any]]]: kwargs: Dict[str, Any]: logging_obj: LiteLLMLoggingObj: start_time: datetime.datetime: model: str: Returns: Tuple[Optional[EmbeddingResponse], bool]: Returns the final embedding cached response and a boolean indicating if all elements in the list have a cache hit FNrrr)rdataTr embedding)rindexrD prompt_tokens) token_counter)textcount_response_tokensprompt_tokens_detailsr$rcompletion_tokens total_tokensrrrrr)rrrMr,r is_embeddingrrr5)r enumerateappendlenrrFrrrrrGrH litellm.utilsrr=intfloatlitellm.types.utilsr%r`r usagerrr|rrr)rr-r,rMrrrrr.remaining_listrkwargs_input_as_listidxr model_nameraggregated_detailsvalembedding_datacached_prompt_tokensr item_detailskeyrr%rrrrrrrs r7rz:LLMCachingHandler._process_async_embedding_cached_responses6:27( "! &*&J&J6&R / 0GCz%%&:3&?@$$c2Y/  0 )w }  !@@OJ#ZZ0 .? Vc"677/ +KO + : :; GM.2 $ @R>%'VVK%8N%1DM&4"%#.E7<@JC)%#u>:L:P:PQTVW:X[`:` 23 7:? 23 7 @- @: GGK !!1,F,\I[,\)!+"#*&; E 5: + 1 ~ ! ##I/3 ,&//335H (($*JJ/Dd$KJ5 9d3   #  8 8'=!$7 9   2 2'=%!# 3 34TT T.0PPPW!1,0)1s(I:: JJusage1usage2c t|j|jz|j|jz|j|jz|j |j |j S)Nr)r rrr_merge_prompt_tokens_detailsr)rrrs r7 combine_usagezLLMCachingHandler.combine_usage1sk ..1E1EE$669Q9QQ,,v/B/BB"&"C"C,,,,#   r6details1r%details2c^||y||S||St|}t|}i}t|jt|jzD]1}|j|d}|j|d}t |t t frt |t t fr ||z||<]t |trt |tri} t|jt|jzD]h} |j| d} |j| d} t | t t frt | t t fr | | z| | <\| r| | | <d| | | <j| ||<$|r|||<-|||<4|syddlm }  | di|S#t$rYywxYw)zGMerge two PromptTokensDetailsWrapper objects by summing numeric fields.Nrr$r5) rXsetkeysrFrGrrrrr%r`)rrrdict1dict2mergedrv1v2nestednknv1nv2r%s r7rz.LLMCachingHandler._merge_prompt_tokens_details<s   0  O  O8B8B uzz|$s5::<'88 !C3"B3"B"sEl+ 2U|0L 2gs B%*R*>!bggi.3rwwy>9)B&&Q-C&&Q-C!#U|4C#u9V%(3Yr %(r %(r )%s  s  s + !.B -77 7  sF F,+F,_caching_handler_responseembedding_responserc\|j|Sd}g}|jjD]E}|0|j$|j|j||dz }5|j|G||j_d|jjd<||z j dz|j_|jj L|j @|j|jj |j |j_|jS)a Combines the cached embedding response with the API EmbeddingResponse For caching there can be a cache hit for some of the inputs in the list and a cache miss for others This function combines the cached embedding response with the API EmbeddingResponse Args: caching_handler_response: CachingHandlerResponse: embedding_response: EmbeddingResponse: Returns: EmbeddingResponse: rTrr)rr)r-rrr total_seconds _response_msrr)rrrrrrrfinal_data_listitems r72_combine_cached_embedding_response_with_api_resultzDLLMCachingHandler._combine_cached_embedding_response_with_api_resultns3( % D D L% %!#-MMRR -D| 2 7 7 C&&'9'>'>s'CDq&&t,  -JY!AAF`d!AAPPQ\] z ! -/DR!!AAN & E E K K W"((4NRN`N`0PPVV)//OaO % E E K )HHHr6rcddlm}|j|j|||||j ||||y)a Helper function to log the success of a cached result on callbacks Args: logging_obj (LiteLLMLoggingObj): The logging object. cached_result: The cached result. start_time (datetime): The start time of the operation. end_time (datetime): The end time of the operation. cache_hit (bool): Whether it was a cache hit. r)GLOBAL_LOGGING_WORKERr)async_coroutineN))litellm.litellm_core_utils.logging_workerrensure_initialized_and_enqueueasync_success_handlerr)rrr,rrrrrs r7rz3LLMCachingHandler._async_log_cache_hit_on_callbackss\$ T<<'==$%!# > =  AA ! B r6cKtjy|j}|jt |j ||j d|jdd|j ddur&d|vr"tjjd i||d<t||_ d}|tjjk(rt|dtr |dg|d<nt|dt s t#dg}t%|dD]d\}}tjjd ii|d|i} |j'tjj)| |j*ft-j.|d{}|$t|t rt1d |Drd}|S|j} t3| } | jddtjj5durh| xstjjd i| |_tjj(d |j*|j6d | d{}|S| xstjjd i| |_tjj8d |j*|j6d | }|S7B7iw) a Internal method to - get cache key - check what type of cache is used - Redis, RedisSemantic, Qdrant, S3 - async get cache value - return the cached value Args: call_type: str: kwargs: Dict[str, Any]: args: Optional[Tuple[Any, ...]] = None: Returns: Optional[Any]: Raises: None NrrOTrmrr)rmdynamic_cache_objectc3$K|]}|du ywrer5).0rs r7 z9LLMCachingHandler._retrieve_from_cache..sB&v~Bs)rrmr5)r|r}rrrrqrFrrr@r9rrrrGrHrrrrasync_get_cacher~r]gatherallrn_supports_asyncr{r) rrrMrrr,tasksrir{r9request_cache_keys r7rz&LLMCachingHandler._retrieve_from_caches( == "KKM  "&&  >>* % - NN:t , >>( #t + :0M&-mm&A&A&OJ&OJ{ #;JG$(  ,,22 2*W-s3'1'':&; 7# 7 3T: !CDDE#Jw$78 Q#*==#>#>#\A[JA[PWYZA[#\  MM11"2-1__2 #*..%"88M(Z t-LBMBB$(M(%%/OO$5N'9.'I    {D 1}},,.$6(9(jW]]=X=X=j[i=j%&-mm&C&C')-"33'%'!  ):(jW]]=X=X=j[i=j% ' 7 7!)-"33!%! 39!s&FK"KCK"6K 7A'K" K"rc *ddlm}|tjjk(s|tj jk(rLt |tr<|jdddur|j||||}n||t}|tjjk(s|tjjk(rHt |tr8|jdddur|j||||}ntdi|}n|tjjk(s|tjjk(r%t |tr||t!d }n-|tj"jk(s|tj$jk(rt |tr ||d d }n|tj&jk(s|tj(jk(r,t |trd |dd } ||t+d| }np|tj,jk(s|tj.jk(r#t |trddlm} | |||}n|dk(s|dk(rt |trt5|} | rv|jdddurO|dk(rtjjntj j} |j|| ||}n||t}nuddlm} t;di|}t=|dr5|j>)t |j>trd|j>d<|jdddur | ||||}n|}t=|dr5|j>)t |j>trd|j>d<tA|||||jBtDjDjG|S)aH Internal method to process the cached result Checks the call type and converts the cached result to the appropriate model response object example if call type is text_completion -> returns TextCompletionResponse object Args: cached_result: Any: call_type: str: kwargs: Dict[str, Any]: logging_obj: LiteLLMLoggingObj: model: str: custom_llm_provider: Optional[str] = None: args: Optional[Tuple[Any, ...]] = None: Returns: Optional[Any]: r) convert_to_model_response_objectrOFT)r,rrr)response_objectmodel_response_objectr)rr response_typeNrerankz whisper-1)rrraudio_transcription)rrr hidden_params)(convert_cached_anthropic_messages_result)r,rrM aresponses responses)#CachedResponsesAPIStreamingIteratorrr)responser request_datar)rrrrMrrrr5)$rrr acompletionr completionrGrrF_convert_cached_stream_responseratext_completiontext_completionrrrrarerankratranscription transcriptionranthropic_messagesaanthropic_messagesHlitellm.llms.anthropic.experimental_pass_through.messages.response_cacherrL$litellm.responses.streaming_iteratorrrrWrrrrrr)rr,rrMrrrrrrruse_chat_completion_cachebridge_call_typer response_objs r7rz:LLMCachingHandler._convert_cached_result_to_model_responsesH C ..44 4 YEYEYE_E_8_eo 4f zz(E*d2 $ D D"/' + !E! !A$1*7/! 3399 9Y)JcJcJiJi=i-zz(E*d2 $ D D"/' + !E! !7 G G 9//555iFYFYF_F_9_eo 4f = -&7&9)M 9,,222i9CSCSCYCY6Y_i 4` = -&*&M 933999Y)JaJaJgJg=gmw 4n %':!$M = -&;&=3+ M 55;; ;yILiLiLoLo?o- E+'M <'9 +CTacgIh/N}/] %(::h.$67@L7P --33V_VjVjVpVp%%)$H$H&3"2$/# %I%M%E(5.;o%M ';&K]&K L*:;$33?"<#>#>E?CL// <::h.$6$G!-$/%+"+ %M%1M M#3 4,,8=77>8z3LLMCachingHandler.async_set_cache.. s, > > >"!9=!LV!r6cBjfdjiSr7)async_add_cacher~)r}r result_jsonrsr7r9z3LLMCachingHandler.async_set_cache..s. 5 5 5'!15!)!r6c*jfiSre)r;)r}rrsr7r9z3LLMCachingHandler.async_set_cache..s0E0E0Ef0[PZ0[r6)'litellm.litellm_core_utils.core_helpersr(r|r}rrr_should_store_result_in_cacherGrrrrrrrkmodel_dump_json) rrrqrMrr(rr}rr<s `` @@@r7async_set_cachez!LLMCachingHandler.async_set_caches*  == }}"KKM  "!  #DJ"O)9 %&  - -@QZd - e67#8#89fg&?&?@f&;<fn5f&:;v'89&u{{G<+ *0)?)?)AK+(([\7 fsEEc |j}|jt|j|tj y|j |j|r t j j|fi|y)zE Sync internal method to add the result to the cache Nr5)rrrrqr|r}r? add_cache)rrrMrrs r7sync_set_cachez LLMCachingHandler.sync_set_cachest#KKM  "&&  ==   - -@V@V_i - j MM # #F 9j 9r6ctjduxrstjjduxrUt|jtjjvxr$|j dij ddduS)z Helper function to determine if the result should be stored in the cache. Returns: bool: True if the result should be stored in the cache, False otherwise. Nr}zno-storeFT)r|r}supported_call_typesrHr/rF)rrqrMs r7r?z/LLMCachingHandler._should_store_result_in_cache4sy]]$ & M 22$> M&//0GMM4V4VV MGR(,,Z?tK  r6z3_StreamResultT | AnthropicMessagesStreamCacheWriterc(|tjjtjjfvr|Stj '|j |j|js|St|ts|Sddl m }|||S)Nr5rr")rOcaching_handler) rr'rr(r|r}r?rqr9rGrr)r#)rrrr#s r7wrap_streaming_result_for_cachez1LLMCachingHandler.wrap_streaming_result_for_cacheBs   ( ( . .  ) ) / /  M == (J(J"44T=P=P)K) M&-0M 2QUVVr6ctjJtjj0t|jtjjvryy)aO Helper function to determine if the call type is supported by the cache. call types are acompletion, aembedding, atext_completion, atranscription, arerank Defined on `litellm.types.utils.CallTypes` Returns: bool: True if the call type is supported by the cache, False otherwise. TF)r|r}rFrHr/)rrqs r7rz2LLMCachingHandler._is_call_type_supported_by_cacheVsB MM % 22>%../7==3U3UUr6processed_chunkc Kt||jtjj|j|j d}|1|j ||j|jd{yy7w)z Internal method to add the streaming response to the cache - If 'streaming_chunk' has a 'finish_reason' then assemble a litellm.ModelResponse object - Else append the chunk to self.async_streaming_chunks Trrrrr9streaming_chunksrN)rrqrM)rrrrrr9ryrArqrrKcomplete_streaming_responses r7 _add_streaming_response_to_cachez2LLMCachingHandler._add_streaming_response_to_cachels >&??!**..0#22!%!&??!**..0#22!%!;!;   $ ' 2   2**   3r6rrrc ^|jdd||jdd|jdi|jdi|jdd|jdi|d } tj#tjjdi|| d <nd| d <|j ||jd di| |s|jd dn|jd d|jddt |d|jdd| t d||_y)a Helper function to update the LiteLLMLoggingObj environment variables. Args: logging_obj (LiteLLMLoggingObj): The logging object to update. model (str): The model being used. kwargs (Dict[str, Any]): The keyword arguments from the original function call. cached_result (Any): The cached result to log. is_async (bool): Whether the call is asynchronous or not. is_embedding (bool): Whether the call is for embeddings or not. custom_llm_provider (Optional[str]): The custom llm provider being used. Returns: None logger_fnNrrr model_infoproxy_server_requeststream_response)rUrrrrVrWrXrr{usermessagesrrrOF) rrYoptional_paramslitellm_paramsrroriginal_responseadditional_argsrOrT)rrr5)rFr|r}!_get_preset_cache_key_from_kwargsupdate_environment_variablesrHrcaching_details) rrrrMr,rrrrr\s r7rz9LLMCachingHandler._update_litellm_logging_obj_environments$6 K6# :r2 :r2 **\26$*JJ/Et$L%zz*;R@#6 !  == $181`1`1jci1jN- .15N- .00FD))5A6::j"-vzzRY[]G^JJy$/!-0 ::h. 3 1 '5/' #r6re)FNN)/r/r0r1rrrHrDrrLiteLLMLoggingObjr tupler+rrrrrrrrr4rr rr rrrrrrrrr)rr!rArDr?r&rIrrQrSrrr5r6r7rprps###S&[)#%% #<+/II$I' I %% I  IS#XIFCK 4'I $ &If+/SCSC$SC' SC %% SC  SCS#XSCFCK 4'SC SCj Ad3;6G ADQTI A U3P_K_E`@a filpfp BQ):T)ABQOd23BQS#X BQ ' BQ %% BQBQ  4'- .BQH  E  5  U  0780780 . / 0d0I#90I.0I%% 0I ## 0I  0Id" &" " %% " ## "  " HKK&*3;&7K?DVS[?QK tKj+/gggS&[! g ' g  gFCK g!4Zg   !           gR   '      D+/ B]B]$B]S#X B] FCK 4' B]P+/ S&[!FCK 4' 2  x  QUVY[^V^Q_  dh  W$W14W >W(# ,m8]:#*.*.: &: : S#X :  :  : : !4Z: !4<: r6rprqr.ctj|}t|jj }i}|r,t |D]\}}|t |ks||}|||< |Sre)inspect signaturer parametersrrr)rqrrf param_namesargs_to_kwargsrarg param_names r7rrsz (():;Ii22779:KN #D/ 1JE3s;''(/ -0z* 1 r6re)Or2r]rrercollections.abcrrrrrrtypingr r r r r pydanticrr|litellm._loggingrrrxrlitellm.caching.cachingrlitellm.constantsr?litellm.litellm_core_utils.llm_response_utils.response_metadatar(litellm.litellm_core_utils.logging_utilsrlitellm.types.cachingrlitellm.types.llms.openairlitellm.types.rerankrrrrrrrrrr *litellm.litellm_core_utils.litellm_loggingr!rbr)r#r%r&r>r(,litellm.litellm_core_utils.streaming_handlerr)r+r8r3rrHrDr@r4rLrRrXrrYrcrkrnrprcrr5r6r7rys  bb??:)+H2:/   W?)*M 3Y 3+_U, S$sF{2C SSRX[HY S &4&D& /4V ;L /QU /[/K[PWX[]cXcPd[ ;>%uS!567? HRQZ[_Q`M`Da fj 8B $4G+HMa1wsCx'81S4Z1 | | B"'+  t # #v+r6