AHjddlZddlZddlmZmZmZmZmZmZm Z m Z ddl m Z ddl mZddlmZddlmZddlmZmZddlmZdd lmZmZmZmZmZmZmZm Z m!Z!er6dd l"m#Z#dd l$m%Z&dd l'm(Z(dd l)m*Z+ddl,m-Z-ddl.m/Z/m0Z0m1Z1ddl2m3Z3e e&efZ%neZ%eZ+eZ-eZ/eZ0eZ1eZ4eZ5eZ3ejldejnZ8GddZ9y)N) TYPE_CHECKINGAnyAsyncGeneratorDictListOptionalTupleUnion) BaseModelverbose_logger)/DEFAULT_MAX_RECURSE_DEPTH_SENSITIVE_DATA_MASKER) ArgillaItem)AllMessageValuesChatCompletionRequest) PromptSpec) AdapterCompletionStreamWrapper CallTypesCallTypesLiteralLLMResponseTypes ModelResponseModelResponseStreamStandardAuditLogPayloadStandardCallbackDynamicParamsStandardLoggingPayload) HTTPException)Span) DualCache)Logging)UserAPIKeyAuth)MCPPostCallResponseObjectMCPPreCallRequestObjectMCPPreCallResponseObject)PreRoutingHookResponsezOdata:(?:application|image|audio|video)/[a-zA-Z0-9.+-]+;base64,[A-Za-z0-9+/=\s]+c DeZdZ d}dededdfdZed~deedeefdZ dZ d Z d Z d Z d Zd ZdZdedededeefdZdZdZddZ ddedeededeedeedededeedeeedeedeedeed eedeeeeeffd!Z ddedeededeedeededeedeedeedeed eedeeeeeffd"Z dded#edeeeeefd$eeeefd%eedee f d&Z! dded'edeeed#eed(ee"deef d)Z#deee$fd*ee%deefd+Z&d,ed(ee"deefd-Z'd,edeefd.Z(d/ed0e)d*ee%dee)fd1Z*d/ed2e$d*ee%dee$fd3Z+d4e,d5eedefd6Z-d5eded7e,fd8Z.d5eded7e,fd9Z/dee0fd:Z1d0e2dee3fd;Z4de7d?ee8dee7fd@Z9 dAe:dBdCdDed*e;deee,eeff dEZ< ddDedAe:d0e$dFeeeefdGeeee$fdeeeeff dHZ= d~d/ed7e,dAe:dIeededJf dKZ>dDedAe:d0e)de$fdLZ?dedMe$d*edeee$ffdNZ@dedMe$d*edeee$ffdOZAdDedAe:d*e;de$fdPZBdAe:d0ede$fdQZCdAe:d0e$d/edeDeEdffdRZFdSZGdTZHdUZIdVZJdWeKdeeKfdXZLd0e$dedeedeeedYedZededeeeffd[ZMdededeed0e$d\e$d]ed^d_dYedede$fd`ZNd0e$dedeedeeedYedZededeeeffdaZOdededeed0e$dbed^d_dYedede$fdcZPdde8fdeZQdde8dfedgeddfdhZRdiedgedefdjZS d~d#eedeefdkZTdledefdmZUdnedeefdoZVdefdpZWeXfdqdrdseddrfdtZYeXfdqdrdseddrfduZZdveXfdwe$dxedsede$fdyZ[dze$defd{Z\eXfdee$dsedeeee$ffd|Z]y) CustomLoggerturn_off_message_loggingmessage_loggingreturnNc ||_||_y)a Args: turn_off_message_logging: bool - if True, the message logging will be turned off. Message and response will be redacted from StandardLoggingPayload. message_logging: bool - deprecated param, use `turn_off_message_logging` instead N)r(r')selfr'r(kwargss Z/root/tools/cai/cai_env/lib/python3.12/site-packages/litellm/integrations/custom_logger.py__init__zCustomLogger.__init__Fs /(@% callback_namec|gS|j}ddi}|j||} ddlm}|}t ||d}|gSt |dd}|sgSt |S#t$rgcYSwxYw)a2 Return the environment variables associated with a given callback name as defined in the proxy callback registry. Args: callback_name: The name of the callback to look up. Returns: List[str]: A list of required environment variable names. N langfuse_otellangfuser) AllCallbackslitellm_callback_params)lowergetlitellm.proxy._typesr4 Exceptiongetattrlist)r0normalized_name alias_map lookup_namer4 callbacks callback_infoparamss r-get_callback_env_varsz"CustomLogger.get_callback_env_varsVs  I'--/ Z  mmO_E   9!N  ;=  I(A4HIF| I sA&& A43A4cyNr+modelmessagesr,s r-log_pre_api_callzCustomLogger.log_pre_api_call| r/cyrDrEr+r, response_obj start_timeend_times r-log_post_api_callzCustomLogger.log_post_api_callrJr/cyrDrErLs r-log_stream_eventzCustomLogger.log_stream_eventrJr/cyrDrErLs r-log_success_eventzCustomLogger.log_success_eventrJr/cyrDrErLs r-log_failure_eventzCustomLogger.log_failure_eventrJr/c KywrDrErLs r-async_log_stream_eventz#CustomLogger.async_log_stream_event  c KywrDrErFs r-async_log_pre_api_callz#CustomLogger.async_log_pre_api_callrYrZrGrHr,c Kyw)a Hook called before making the API request to allow modifying request parameters. This is specifically designed for modifying the request before it's sent to the provider. Unlike async_log_pre_api_call (which is for logging), this hook is meant for transformations. Args: model: The model name messages: The messages list kwargs: The request parameters (tools, stream, temperature, etc.) Returns: Optional[Dict]: Modified kwargs to use for the request, or None if no modifications Example: ```python async def async_pre_request_hook(self, model, messages, kwargs): # Convert native tools to standard format if kwargs.get("tools"): kwargs["tools"] = convert_tools(kwargs["tools"]) return kwargs ``` NrErFs r-async_pre_request_hookz#CustomLogger.async_pre_request_hooks 4 rZc KywrDrErLs r-async_log_success_eventz$CustomLogger.async_log_success_eventrYrZc KywrDrErLs r-async_log_failure_eventz$CustomLogger.async_log_failure_eventrYrZc Kyw)zFCalled when an audit log is created. Override in subclasses to handle.NrE)r+ audit_logs r-async_log_audit_log_eventz&CustomLogger.async_log_audit_log_events  rZnon_default_params prompt_idprompt_variablesdynamic_callback_paramslitellm_logging_obj prompt_spectools prompt_labelprompt_versionignore_prompt_manager_model%ignore_prompt_manager_optional_paramscK|||fSwax Returns: - model: str - the model to use (can be pulled from prompt management tool) - messages: List[AllMessageValues] - the messages to use (can be pulled from prompt management tool) - non_default_params: dict - update with any optional params (e.g. temperature, max_tokens, etc.) to use (can be pulled from prompt management tool) rE)r+rGrHrfrgrhrirjrkrlrmrnrorps r- async_get_chat_completion_promptz-CustomLogger.async_get_chat_completion_prompts,h 222sc  |||fSrrrE) r+rGrHrfrgrhrirkrmrnrorps r-get_chat_completion_promptz'CustomLogger.get_chat_completion_prompts(h 222r/request_kwargsinputspecific_deploymentc Kyw)z This hook is called before the routing decision is made. Used for the litellm auto-router to modify the request before the routing decision is made. NrE)r+rGrvrHrwrxs r-async_pre_routing_hookz#CustomLogger.async_pre_routing_hooks rZhealthy_deploymentsparent_otel_spancK|SwrDrE)r+rGr{rHrvr|s r-async_filter_deploymentsz%CustomLogger.async_filter_deploymentss#"s call_typec Kyw)a Allow modifying the request just before it's sent to the deployment. Use this instead of 'async_pre_call_hook' when you need to modify the request AFTER a deployment is selected, but BEFORE the request is sent. Used in managed_files.py NrE)r+r,rs r-async_pre_call_deployment_hookz+CustomLogger.async_pre_call_deployment_hooks  rZ deploymentc KywrDrE)r+rr|s r-async_pre_call_checkz!CustomLogger.async_pre_call_check  rZcyrDrE)r+rs r-pre_call_checkzCustomLogger.pre_call_checkrJr/ request_dataresponsec Kyw)zh Allow modifying / reviewing the response just after it's received from the deployment. NrE)r+rrrs r-'async_post_call_success_deployment_hookz4CustomLogger.async_post_call_success_deployment_hook  rZresponse_chunkc Kyw)z Allow modifying streaming chunks just before they're returned to the user. This is called for each streaming chunk in the response. NrE)r+rrrs r-)async_post_call_streaming_deployment_hookz6CustomLogger.async_post_call_streaming_deployment_hook&s  rZ exceptionoriginal_model_groupc KywrDrE)r+rrr,s r- log_model_group_rate_limit_errorz-CustomLogger.log_model_group_rate_limit_error4rrZoriginal_exceptionc KywrDrEr+rr,rs r-log_success_fallback_eventz'CustomLogger.log_success_fallback_event9rrZc KywrDrErs r-log_failure_fallback_eventz'CustomLogger.log_failure_fallback_event>rrZcy)zt Translates the input params, from the provider's native format to the litellm.completion() format. NrE)r+r,s r-!translate_completion_input_paramsz.CustomLogger.translate_completion_input_paramsE r/cy)z\ Translates the output params, from the OpenAI format to the custom format. NrE)r+rs r-"translate_completion_output_paramsz/CustomLogger.translate_completion_output_paramsMrr/completion_streamcy)z^ Translates the streaming chunk, from the OpenAI format to the custom format. NrE)r+rs r-,translate_completion_output_params_streamingz9CustomLogger.translate_completion_output_params_streamingUrr/ logged_itemstandard_logging_payloadc Ktdw)z - Decide if the result should be logged to Argilla. - Modify the result before logging to Argilla. - Return None if the result should not be logged to Argilla. z"async_dataset_hook not implemented)NotImplementedError)r+rrs r-async_dataset_hookzCustomLogger.async_dataset_hook_s""FGGs user_api_key_dictcacherdatac KywrDrE)r+rrrrs r-async_pre_call_hookz CustomLogger.async_pre_call_hookprrZrequest_headerslitellm_call_infoc Kyw)a Called after an LLM API call (success or failure) to allow injecting custom HTTP response headers. Args: - data: dict - The request data. - user_api_key_dict: UserAPIKeyAuth - The user API key dictionary. - response: Any - The response object (None for failure cases). - request_headers: Optional[Dict[str, str]] - The original request headers. - litellm_call_info: Optional[Dict[str, Any]] - Normalized routing metadata: - custom_llm_provider: str - The LLM provider (e.g. "openai", "azure") - model_info: dict - The model_info from router config - api_base: str - The API base URL used - model_id: str - The deployment model ID Returns: - Optional[Dict[str, str]]: A dictionary of headers to inject into the HTTP response. Return None to not inject any headers. NrE)r+rrrrrs r-%async_post_call_response_headers_hookz2CustomLogger.async_post_call_response_headers_hook{s 4rZ traceback_strrc Kyw)au Called after an LLM API call fails. Can return or raise HTTPException to transform error responses. Args: - request_data: dict - The request data. - original_exception: Exception - The original exception that occurred. - user_api_key_dict: UserAPIKeyAuth - The user API key dictionary. - traceback_str: Optional[str] - The traceback string. Returns: - Optional[HTTPException]: Return an HTTPException to transform the error response sent to the client. Return None to use the original exception. NrE)r+rrrrs r-async_post_call_failure_hookz)CustomLogger.async_post_call_failure_hooks ( rZc KywrDrE)r+rrrs r-async_post_call_success_hookz)CustomLogger.async_post_call_success_hook rZresultcK||fSwzUFor masking logged request/response. Return a modified version of the request/result.rEr+r,rrs r-async_logging_hookzCustomLogger.async_logging_hooksv~c ||fSrrErs r- logging_hookzCustomLogger.logging_hooksv~r/c KywrDrE)r+rrrs r-async_moderation_hookz"CustomLogger.async_moderation_hookrrZc KywrDrE)r+rrs r-async_post_call_streaming_hookz+CustomLogger.async_post_call_streaming_hooks rZc4K|23d{}|7 6ywrDrE)r+rrritems r-'async_post_call_streaming_iterator_hookz4CustomLogger.async_post_call_streaming_iterator_hooks$ #  $J (sc ||d<||d<d|d<|||d|y#t$r |dtjYywxYwNrGrH pre_api_calllog_event_typez$Custom Logger - model call details: Custom Logger Error - r9 traceback format_excr+rGrHr, print_verbose callback_funcs r-log_input_eventzCustomLogger.log_input_eventsn M#F7O!)F: '5F# $   @I J M 293G3G3I2JK L Ms"%&A AcK ||d<||d<d|d<||d{|d|y7#t$r |dtjYywxYwwrrrs r-async_log_input_eventz"CustomLogger.async_log_input_events M#F7O!)F: '5F# $   @I J  M 293G3G3I2JK L Ms1A1/1A1&AAAAc~ d|d<|||||y#t$r |dtjYywxYwN post_api_callrrrr+r,rMrNrOrrs r- log_eventzCustomLogger.log_eventsT '6F# $      293G3G3I2JK L  s &<<cK d|d<|||||d{y7#t$r |dtjYywxYwwrrrs r-async_log_eventzCustomLogger.async_log_eventsa '6F# $      293G3G3I2JK L  s1A A &AA AA rMc Kyw)z This log gets called after the MCP tool call is made. Useful if you want to modiy the standard logging payload after the MCP tool call is made. NrErLs r-async_post_mcp_tool_call_hookz*CustomLogger.async_post_mcp_tool_call_hooks rZstreamcustom_llm_providercKdifSw)a Hook to determine if agentic loop should be executed. Called after receiving response from model, before returning to user. USE CASE: Enables transparent server-side tool execution for models that don't natively support server-side tools. User makes ONE API call and gets back the final answer - the agentic loop happens transparently on the server. Example use cases: - WebSearch: Intercept WebSearch tool calls for Bedrock/Claude, execute litellm.search(), return final answer with search results - Code execution: Execute code in sandboxed environment, return results - Database queries: Execute queries server-side, return data to model - API calls: Make external API calls and inject responses back into context Flow: 1. User calls litellm.messages.acreate(tools=[...]) 2. Model responds with tool_use 3. THIS HOOK checks if tool should run server-side 4. If True, async_run_agentic_loop executes the tool 5. User receives final answer (never sees intermediate tool_use) Args: response: Response from model (AnthropicMessagesResponse or AsyncIterator) model: Model name messages: Original messages sent to model tools: List of tool definitions from request stream: Whether response is streaming custom_llm_provider: Provider name (e.g., "bedrock", "anthropic") kwargs: Additional request parameters Returns: (should_run, tools): should_run: True if agentic loop should execute tools: Dict with tool_calls and metadata for execution Example: # Detect WebSearch tool call if has_websearch_tool_use(response): return True, { "tool_calls": extract_tool_calls(response), "tool_type": "websearch" } return False, {} FrEr+rrGrHrlrrr,s r-async_should_run_agentic_loopz*CustomLogger.async_should_run_agentic_loop'spbyr"anthropic_messages_provider_config*anthropic_messages_optional_request_params logging_objLiteLLMLoggingObjc  Kyw)aI Hook to execute agentic loop based on context from should_run hook. Called only if async_messages_should_run_agentic_loop returns True. USE CASE: Execute server-side tools and orchestrate the agentic loop to return a complete answer to the user in a single API call. What to do here: 1. Extract tool calls from tools dict 2. Execute the tools (litellm.search, code execution, DB queries, etc.) 3. Build assistant message with tool_use blocks 4. Build user message with tool_result blocks containing results 5. Make follow-up litellm.messages.acreate() call with results 6. Return the final response Args: tools: Dict from async_should_run_agentic_loop Contains tool_calls and metadata model: Model name messages: Original messages sent to model response: Original response from model (with tool_use) anthropic_messages_provider_config: Provider config for making requests anthropic_messages_optional_request_params: Request parameters (tools, etc.) logging_obj: LiteLLM logging object stream: Whether response is streaming kwargs: Additional request parameters Returns: Final response after executing agentic loop (AnthropicMessagesResponse with final answer) Example: # Extract tool calls tool_calls = agentic_context["tool_calls"] # Execute searches in parallel search_results = await asyncio.gather( *[litellm.asearch(tc["input"]["query"]) for tc in tool_calls] ) # Build messages with tool results assistant_msg = {"role": "assistant", "content": [...tool_use blocks...]} user_msg = {"role": "user", "content": [...tool_result blocks...]} # Make follow-up request from litellm.anthropic_interface import messages final_response = await messages.acreate( model=model, messages=messages + [assistant_msg, user_msg], max_tokens=anthropic_messages_optional_request_params.get("max_tokens"), **anthropic_messages_optional_request_params ) return final_response NrE) r+rlrGrHrrrrrr,s r-async_run_agentic_loopz#CustomLogger.async_run_agentic_loopas H rZcKdifSw)zW Hook to determine if chat completion agentic loop should be executed. FrErs r--async_should_run_chat_completion_agentic_loopz:CustomLogger.async_should_run_chat_completion_agentic_loopsbyroptional_paramsc  Kyw)ze Hook to execute chat completion agentic loop based on context from should_run hook. NrE) r+rlrGrHrrrrr,s r-&async_run_chat_completion_agentic_loopz3CustomLogger.async_run_chat_completion_agentic_loops  rZstandard_logging_objectcFd}gd}|D]}|j|||y)a Truncate error strings and message content in logging payload Some loggers like DataDog/ GCS Bucket have a limit on the size of the payload. (1MB) This function truncates the error string and the message content if they exceed a certain length. i') error_strrHr)r field_name max_lengthN)_truncate_field)r+rMAX_STR_LENGTHfields_to_truncatefields r-)truncate_standard_logging_payload_contentz6CustomLogger.truncate_standard_logging_payload_contents= C' E  (? ) !  r/rrc|j|}|r1t|}t||kDr|j||||<yyy)aP Helper function to truncate a field in the logging payload This converts the field to a string and then truncates it if it exceeds the max length. Why convert to string ? 1. User was sending a poorly formatted list for `messages` field, we could not predict where they would send content - Converting to string and then truncating the logged content catches this 2. We want to avoid modifying the original `messages`, `response`, and `error_str` in the logging payload since these are in kwargs and could be returned to the user )textrN)r7strlen_truncate_text)r+rrr field_value str_values r-rzCustomLogger._truncate_fieldsX .11*= K(I9~ *6:6I6I"z7J7' 3+ r/rc2t||kDr|d|dzS|S)z&Truncate text if it exceeds max_lengthNzC...truncated by litellm, this logger does not support large content)r)r+rrs r-rzCustomLogger._truncate_texts4 4y:% * S T   r/c(ddlm}m}|y||vr|S|S)z Select the metadata field to use for logging 1. If `litellm_metadata` is in the request kwargs, use it 2. Otherwise, use `metadata` r)LITELLM_METADATA_FIELDOLD_LITELLM_METADATA_FIELDN)litellm.constantsrr)r+rvrrs r-_select_metadata_fieldz#CustomLogger._select_metadata_fields% Y  ! !^ 3) )))r/model_call_detailsc0ddl}ddlm}ddlm}m}m}t |dd}t |dd}|dur|s|S||} |j d} | | S|| } |r|D] } | | vs| | = |r!d } d |xsgvr,| j d || jg| d <d |xsgvr| j d | d }t|trd |vrddlm }||}t|j d trY|d D]Q}t|tsd|vst|dts-|dD]}t|tsd|vs| |d<S|| d <n-|||| g}|j}|| d <| | d<| S)a Redacts or excludes fields from StandardLoggingPayload before callbacks receive it. This method handles two features: 1. turn_off_message_logging: When True, redacts messages and responses 2. standard_logging_payload_excluded_fields: Removes specified fields entirely Return a modified copy of the provided logging payload. This is useful for logging payloads that contain sensitive information. rN)copy)ChoicesMessagerr'F(standard_logging_payload_excluded_fieldsrzredacted-by-litellmrHcontentroutput)deepcopyr r)message)choices) litellmrrrrr:r7 model_dump isinstancedictr r;)r+rrrrrrr'excluded_fieldsmodel_call_details_copyrstandard_logging_object_copyr redacted_strrr  response_copy output_item content_itemmodel_responsemodel_response_dicts r-7redact_standard_logging_payload_from_model_call_detailszDCustomLogger.redact_standard_logging_payload_from_model_call_detailss ;;)0 ,e*  07 ?0  $u ,_% %#''9":"4"8"89R"S " ** *(,,C'D$ ( <884U; < $0L?#8b9044Z@LL1<<><,Z8 ?#8b9044Z@L7 Ch-(h2F-$,X$6M!-"3"3H"=tD+8+B PK *; =$-$<#-k).Dd#K8CI8N%P ,6|T,J06,0FCOL,@ %P P@M0<&3!(1N!O P&N+9*C*C*E'?R0< ) % '&r/ object_keyc Kyw)z_ Get the proxy server request from cold storage using the object key directly. NrE)r+rs r-:get_proxy_server_request_from_cold_storage_with_object_keyzGCustomLogger.get_proxy_server_request_from_cold_storage_with_object_keyrs  rZc l ddl}ddlm}|jj }|D]7}t |ds|j d||j|y|j d|dy#t$r1}ddlm}|j d |d t|Yd}~yd}~wwxYw) z Handle callback logging failures by incrementing Prometheus metrics. Call this method in exception handlers within your callback when logging fails. rNr "increment_callback_logging_failurez)Incrementing callback failure metric for )r0zENo callback with increment_callback_logging_failure method found for z2. Ensure 'prometheus' is in your callbacks config.z%Error in handle_callback_failure for z: ) rlitellm._loggingr logging_callback_manager_get_all_callbackshasattrdebugr!r9r)r+r0rr all_callbacks callback_objes r-handle_callback_failurez$CustomLogger.handle_callback_failure{s    7#<<OOQM -  <)MN(N((CM?S!CCR_C`   !N WXeWfgCC    7 N 7 bQQ   s"5A9(A9!A99 B3'B..B3payloadr max_depthcK|jdg}t|tr|ng}tjdt |d|r|j |||d<d}|jdgxsgD]D}t|ts|jdg}t|ts7|t |z }Ftjd|d|Sw u Removes or redacts base64-encoded file data (e.g., PDFs, images, audio) from messages and responses before sending to SQS. Behavior: • Drop entries with a 'file' key. • Drop entries with type == 'file' or any non-text type. • Keep untyped or text content. • Recursively redact inline base64 blobs in *any* string field, at any depth. rHz%[CustomLogger] Stripping base64 from z messages)rHr,rr z0[CustomLogger] Completed base64 strip; retained z content itemsr7rr;r r&r_process_messagesrr+r+r, raw_messagesrH total_itemsmr s r-_strip_base64_from_messagesz(CustomLogger._strip_base64_from_messagess$KK B7 .8t.LlRT3CM?) L  "&"8"8!Y#9#GJ  Z,2 0A!T"%% 2.gt,3w</K  0 >{m> Z sB C"C2+Cc|jdg}t|tr|ng}tjdt |d|r|j |||d<d}|jdgxsgD]D}t|ts|jdg}t|ts7|t |z }Ftjd|d|Sr.r/r1s r- _strip_base64_from_messages_syncz-CustomLogger._strip_base64_from_messages_syncs$KK B7 .8t.LlRT3CM?) L  "&"8"8!Y#9#GJ  Z,2 0A!T"%% 2.gt,3w</K  0 >{m> Z r/rvaluedepthc ||kDrtjd|dyt|trItj |r2tj d|dddtjd|S|St|tr%|Dcgc]}|j||d z| c}St|tr9|jDcic]\}}||j||d z| c}}S|Scc}wcc}}w) z\Recursively redact inline base64 from any nested structure with a max recursion depth limit.z#[CustomLogger] Max recursion depth z reached while redacting base64z[MAX_DEPTH_REACHED]z.[CustomLogger] Redacted inline base64 string: N(z...z[BASE64_REDACTED])r8r9r,) r warningrr_BASE64_INLINE_PATTERNsearchr&subr;_redact_base64ritems)r+r8r9r,vks r-rAzCustomLogger._redact_base64s 9   " "5i[@_` ) eS !%,,U3$$DU3BZLPST.112EuMML eT "##!519 #R  eT ""KKMAq4&&Qeai9&UU    s C9"C>r ct|tsyd|vry|jd}t|txr|dk7 S)z4Return True if this content item should be retained.TfileFtyper)rrr7r)r+r ctypes r-_should_keep_contentz!CustomLogger._should_keep_content sA'4( W  F#uc*>u??r/cg}|D]}t|ts|jd}t|trDg}|D]7}|j |s|j |j ||9||d<n|j |||d<t|jD]!\}} |dk7s |j | |||<#|j ||S)Nr r )r8r,)rrr7r;rIappendrArB) r+rHr,filtered_messagesmsgcontentscleanedckeyvals r-r0zCustomLogger._process_messagess 35 *Cc4(GGI.H(D)%'!A000; //a9/M ")I!%!4!4"i"5"I!- SS)##22 2RCH S  $ $S )) **! r/)FTrD)rdr)NNNNFF)NNNFF)NNF)NN)^__name__ __module__ __qualname__boolr. staticmethodrrrrBrIrPrRrTrVrXr\rr^r`rbrerrrrrintr rsrur r$rzrr~rrrrrrrrr9rrrrrrr rrrrrrr rrrrrrrrrrrrrrrrr!rrrrrrrrrrrr*rr5r7rArIr0rEr/r-r&r&Ds> */ $  "&     #Xc]#d3i##J         $( 26 $ 8   -1&*&*(,6;@E33'(3! 3 C= 3 #4. 3"?3/3j)3T #3sm3! 3&.d^308~3 sD)*D0 13@-1&*(,6;@E33'(3! 3 C= 3 #4. 3"?3j)3sm3! 3&.d^308~3 sD)*D0 13.48,0.3   4S#X/0  c4i()  &d^  ( ) (*.+/ ##"#4 012 # ! # #4. # d#  38n  19)1D  $    2:4. $   (4.     #  I&  " #        I&  #   " :B3- QU  $' 15 KT  $' 15 KT  ' (  % )   !$ 0 1  H  H#++A"B H +  H  )      $   id"#   596: *  "$sCx.1  $DcN3  $sCx. !B(,   & *   }  / "  ,  * #   $'47 tSy  $'47 tSy    * $    )    )  +T1 2  M M ($= + ,888t* 8 T # 8  8!88 tTz 8tD D D t* D  D -0 D 59D )D D D  D L   t*  T #   !   tTz     t*      )     $!7,!7   0 3 C C 04*&tn* #*"`'"&`' `'D   $ SFI$)$$ " $RI$)$$ " $RH !!! ! !F@C@D@I!s)!! d38n  !r/r&):rertypingrrrrrrr r pydanticr r"r rr"litellm.types.integrations.argillarlitellm.types.llms.openairr"litellm.types.prompts.init_promptsrlitellm.types.utilsrrrrrrrrrfastapiropentelemetry.tracer_Spanlitellm.caching.cachingr*litellm.litellm_core_utils.litellm_loggingrrr8r litellm.types.mcpr!r"r#litellm.types.routerr$MCPDuringCallRequestObjectMCPDuringCallResponseObjectcompile MULTILINEr>r&rEr/r-rks    +M:M9   %11W3 <  D DN #!"!$"% $VLL j!j!r/