tPjUddlZddlZddlmZmZddlmZmZmZm Z m Z ddl m Z ddl mZddlmZddlmZddlmZdd lmZmZdd lmZdd lmZmZmZmZmZm Z m!Z!m"Z"m#Z#er4dd l$m%Z%dd l&m'Z(ddl)m*Z*ddl+m,Z-ddl.m/Z/ddl0m1Z1m2Z2m3Z3ddl4m5Z5e(ezZ'neZ'eZ-eZ/eZ1eZ2eZ3eZ6e e7d<eZ8e e7d<eZ5ejrdejtZ;e e7d<GddZeZdZUeZeeeed<dZe ed< dde de ddfdZ e dd edzde efd Z d Zd Zd ZdZdZdZdZdede dededzfdZdZdZddZ ddede edededzdedzdedededzde edzd edzd!edzd"e dzd#e dzdeee eeffd$Z ddede edededzdedzdededzd edzd!edzd"e dzd#e dzdeee eeffd%Z! dded&ede eee"fdzd'ee zdzd(e dzde#dzf d)Z$ dded*e de edzd&edzd+e%dzde ef d,Z&deee"fd-e'dzdedzfd.Z(d/ed+e%dzdedzfd0Z)d/ededzfd1Z*d2ed3e+d-e'dzde+dzfd4Z, dd2e-ee.fd5e/d-e'dzd6edzddf d7Z0d2ed8e"d-e'dzde"dzfd9Z1d5e/d:edzdefd;Z2d:ededZ4de5dzfd?Z6d3e7de8dzfd@Z9dAe"de:dzfdBZ;dCe dFe?dGdHdIed-e@de/ezezdzf dJZA ddIedFe?d3e"dKeeefdzdLeee"fdzdeeefdzf dMZB dd2ed &y+tD  I /H$OIF| I sA&& A43A4cyNr1modelmessagesr2s r3log_pre_api_callzCustomLogger.log_pre_api_call r5cyrJrKr1r2 response_obj start_timeend_times r3log_post_api_callzCustomLogger.log_post_api_callrPr5cyrJrKrRs r3log_stream_eventzCustomLogger.log_stream_eventrPr5cyrJrKrRs r3log_success_eventzCustomLogger.log_success_eventrPr5cyrJrKrRs r3log_failure_eventzCustomLogger.log_failure_eventrPr5c KywrJrKrRs r3async_log_stream_eventz#CustomLogger.async_log_stream_event  c KywrJrKrLs r3async_log_pre_api_callz#CustomLogger.async_log_pre_api_callr_r`rMrNr2c 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 ``` NrKrLs r3async_pre_request_hookz#CustomLogger.async_pre_request_hookr`c KywrJrKrRs r3async_log_success_eventz$CustomLogger.async_log_success_eventr_r`c KywrJrKrRs r3async_log_failure_eventz$CustomLogger.async_log_failure_eventr_r`c Kyw)zFCalled when an audit log is created. Override in subclasses to handle.NrK)r1 audit_logs r3async_log_audit_log_eventz&CustomLogger.async_log_audit_log_eventrer`non_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) rK)r1rMrNrmrnrorprqrrrsrtrurvrws r3 async_get_chat_completion_promptz-CustomLogger.async_get_chat_completion_prompts,h 222sc  |||fSryrK) r1rMrNrmrnrorprrrtrurvrws r3get_chat_completion_promptz'CustomLogger.get_chat_completion_prompts(h 222r5request_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. NrK)r1rMr}rNr~rs r3async_pre_routing_hookz#CustomLogger.async_pre_routing_hooks r`healthy_deploymentsparent_otel_spancK|SwrJrK)r1rMrrNr}rs r3async_filter_deploymentsz%CustomLogger.async_filter_deploymentss#" 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 NrK)r1r2rs r3async_pre_call_deployment_hookz+CustomLogger.async_pre_call_deployment_hookrer` deploymentc KywrJrK)r1rrs r3async_pre_call_checkz!CustomLogger.async_pre_call_checkr_r`cyrJrK)r1rs r3pre_call_checkzCustomLogger.pre_call_checkrPr5 request_dataresponsec Kyw)zh Allow modifying / reviewing the response just after it's received from the deployment. NrK)r1rrrs r3'async_post_call_success_deployment_hookz4CustomLogger.async_post_call_success_deployment_hookrer` exceptionfallback_depthc Kyw)a Called once per failed deployment attempt - attempt 1, every retry, and every fallback chain step - because the router re-invokes the wrapped function on each attempt, re-entering this hook's call site fresh every time. This is a DEPLOYMENT-LEVEL signal, distinct from the REQUEST-LEVEL ``async_log_failure_event``, which fires once per logical client request behind a dedup gate. ``request_data`` is mostly this attempt's own kwargs, with one exception: it omits ``attempted_targets``, the router's own bookkeeping of which fallback targets this request has already tried, since that one object *is* shared by reference across every hop of the live fallback walk. Pairs with ``async_pre_call_deployment_hook`` and ``async_post_call_success_deployment_hook`` to complete the pre-call/success/failure lifecycle for a single deployment attempt. ``fallback_depth`` is best-effort: ``None`` on the first attempt and on any call made without a ``Router`` (a bare SDK call has no fallback chain to be at a depth in), ``1`` on the first fallback hop, ``2`` on the second, and so on. It reflects ``Router``'s own internal fallback bookkeeping (``kwargs["fallback_depth"]``), not a value this hook computes or guarantees the shape of across versions. It tracks fallback hops only, not retries within the same model group - a retry-only failure (no fallback yet) also reports ``None``. If an override predates this field it's simply never passed, rather than raising - safe to leave off an override written before it existed. ``exception`` is a same-class snapshot, not the exact object about to be re-raised to the real caller: read it freely, but setting an attribute on it (e.g. ``status_code``) has no effect on what the caller actually receives. Default: no-op. Opt in by overriding. Keep overrides fast - this runs on the request's exception path, so a slow implementation delays error propagation to the caller. The reported failure duration is captured before this hook runs, so a slow override doesn't inflate that metric, but the caller still waits for it. NrK)r1rrrrs r3'async_post_call_failure_deployment_hookz4CustomLogger.async_post_call_failure_deployment_hook(rer`response_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. NrK)r1rrrs r3)async_post_call_streaming_deployment_hookz6CustomLogger.async_post_call_streaming_deployment_hookXrer`original_model_groupc KywrJrK)r1rrr2s r3 log_model_group_rate_limit_errorz-CustomLogger.log_model_group_rate_limit_errores  r`original_exceptionc KywrJrKr1rr2rs r3log_success_fallback_eventz'CustomLogger.log_success_fallback_eventjr_r`c KywrJrKrs r3log_failure_fallback_eventz'CustomLogger.log_failure_fallback_eventmr_r`cy)zt Translates the input params, from the provider's native format to the litellm.completion() format. NrK)r1r2s r3!translate_completion_input_paramsz.CustomLogger.translate_completion_input_paramsrr5cy)z\ Translates the output params, from the OpenAI format to the custom format. NrK)r1rs r3"translate_completion_output_paramsz/CustomLogger.translate_completion_output_paramswrr5completion_streamcy)z^ Translates the streaming chunk, from the OpenAI format to the custom format. NrK)r1rs r3,translate_completion_output_params_streamingz9CustomLogger.translate_completion_output_params_streaming|rr5 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)r1rrs r3async_dataset_hookzCustomLogger.async_dataset_hooks""FGGs user_api_key_dictcacherdatac KywrJrK)r1rrrrs r3async_pre_call_hookz CustomLogger.async_pre_call_hooks  r`request_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. NrK)r1rrrrrs r3%async_post_call_response_headers_hookz2CustomLogger.async_post_call_response_headers_hooks 4r` 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. NrK)r1rrrrs r3async_post_call_failure_hookz)CustomLogger.async_post_call_failure_hookrer`c KywrJrK)r1rrrs r3async_post_call_success_hookz)CustomLogger.async_post_call_success_hook r`resultcK||fSwzUFor masking logged request/response. Return a modified version of the request/result.rKr1r2rrs r3async_logging_hookzCustomLogger.async_logging_hooksv~c ||fSrrKrs r3 logging_hookzCustomLogger.logging_hooks v~r5c KywrJrK)r1rrrs r3async_moderation_hookz"CustomLogger.async_moderation_hookrr`c KywrJrK)r1rrs r3async_post_call_streaming_hookz+CustomLogger.async_post_call_streaming_hooks r`c4K|23d{}|7 6ywrJrK)r1rrritems r3'async_post_call_streaming_iterator_hookz4CustomLogger.async_post_call_streaming_iterator_hooks$ #  $J (sc ||d<||d<d|d<|||d|y#t$r |dtjYywxYwNrMrN pre_api_calllog_event_typez$Custom Logger - model call details: Custom Logger Error - r? traceback format_excr1rMrNr2 print_verbose callback_funcs r3log_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 r3async_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_callrrrr1r2rSrTrUrrs r3 log_eventzCustomLogger.log_eventsT M'6F# $     M 293G3G3I2JK L Ms &<<cK d|d<|||||d{y7#t$r |dtjYywxYwwrrrs r3async_log_eventzCustomLogger.async_log_event!sa M'6F# $     M 293G3G3I2JK L Ms1A A &AA AA rSc Kyw)aF This log gets called after the MCP tool call is made. Useful if you want to modify the standard logging payload after the MCP tool call is made. To change what the caller sends back to the MCP client, mutate ``response_obj`` in place: every call site discards the returned object, because the dispatcher unwraps it to ``mcp_tool_call_response`` (a raw content list, not a ``CallToolResult``) which the tool-call paths cannot forward. Guardrails that mask or reject tool output should use ``post_mcp_call`` instead. NrKrRs r3async_post_mcp_tool_call_hookz*CustomLogger.async_post_mcp_tool_call_hook2s r`streamcustom_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, {} FrKr1rrMrNrsrrr2s r3async_should_run_agentic_loopz*CustomLogger.async_should_run_agentic_loopFspbyr"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 NrK r1rsrMrNrrrrrr2s r3async_run_agentic_loopz#CustomLogger.async_run_agentic_looprer`c "KtdSw)z Build a typed rerun plan for Anthropic Messages agentic loops. Override this method to separate callback decision/tool execution from follow-up request execution (handled by BaseLLMHTTPHandler). Frun_agentic_looprrs r3async_build_agentic_loop_planz*CustomLogger.async_build_agentic_loop_plans$66 plancK|Sw)aR Post-process the response returned by the agentic-loop follow-up call. Called after BaseLLMHTTPHandler executes ``AgenticLoopPlan.request_patch`` and receives the final response from the provider. Lets callbacks shape what the client sees without bypassing the loop's safety / observability machinery (depth tracking, fingerprinting, etc.). Use ``plan.metadata`` to carry whatever the build step decided to expose for post-processing (e.g. native tool_result blocks to inject). Default returns ``response`` unchanged. rK)r1rrr2s r3%async_post_agentic_loop_response_hookz2CustomLogger.async_post_agentic_loop_response_hooks &rc Kyw)a Release resources held for an agentic-loop iteration. Runs in a ``finally`` around the follow-up provider call, so it fires whether the rerun returns normally, hits a loop safety abort, or raises an upstream error. Implementations must be idempotent because the post-response hook may already have released the same resource on the success path. Use ``plan.metadata`` to locate what to clean up. Default does nothing. NrK)r1rr2s r3async_agentic_loop_cleanup_hookz,CustomLogger.async_agentic_loop_cleanup_hooks r`cKdifSw)zW Hook to determine if chat completion agentic loop should be executed. FrKrs r3-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. NrK r1rsrMrNrrrrr2s r3&async_run_chat_completion_agentic_loopz3CustomLogger.async_run_chat_completion_agentic_looprer`c "KtdSw)zN Build a typed rerun plan for chat-completions agentic loops. Frrrs r3-async_build_chat_completion_agentic_loop_planz:CustomLogger.async_build_chat_completion_agentic_loop_plans66rstandard_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_strrNr)r field_name max_lengthN)_truncate_field)r1rMAX_STR_LENGTHfields_to_truncatefields r3)truncate_standard_logging_payload_contentz6CustomLogger.truncate_standard_logging_payload_content0s=!'%J' E  (? ) !  r5rrc|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)r=strlen_truncate_text)r1rrr field_value str_values r3rzCustomLogger._truncate_fieldFsS 588D ";/I9~ *6:6I6Iyeo6I6p' 3+ r5rc2t||kDr|d|dzS|S)z&Truncate text if it exceeds max_lengthNzC...truncated by litellm, this logger does not support large content)r)r1rrs r3rzCustomLogger._truncate_text\s14y:% *  e e  r5c(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)r1r}rrs r3_select_metadata_fieldz#CustomLogger._select_metadata_fieldds% Y  ! !^ 3) )))r5model_call_detailsc0ddlm}ddl}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. r)copyN)ChoicesMessagerr-F(standard_logging_payload_excluded_fieldsrzredacted-by-litellmrNcontentroutput)deepcopyr!r)message)choices) rlitellmrrrr@r= model_dump isinstancedictr#rA)r1rrr&rrrr-excluded_fieldsmodel_call_details_copyrstandard_logging_object_copyr  redacted_strrr# response_copy output_item content_itemmodel_responsemodel_response_dicts r37redact_standard_logging_payload_from_model_call_detailszDCustomLogger.redact_standard_logging_payload_from_model_call_detailsss ;;07>XZ_0` 3:7Dnpt3u $u ,_% %*..@)A);)?)?@Y)Z " ** */33J.K$ ( <884U; < $"7L/"7R8=Y=]=]^h=i=uz"Jh-(h2F-+3H+=M!-"3"3H"=tD+8+BPK)+t<kAY#-k).Dd#K8CI8N%P +5lD+IfXdNdCOL,@%P P@M0<-:7SZcoSpCqBr,sN1?1J1J1L'?R0<=Y 9:&&r5 object_keyc Kyw)z_ Get the proxy server request from cold storage using the object key directly. NrK)r1r4s r3:get_proxy_server_request_from_cold_storage_with_object_keyzGCustomLogger.get_proxy_server_request_from_cold_storage_with_object_keyrer`cH ddl}ddlm}|jj }|D]5}t |ds|j d||j|y|j d|y#t$r$}ddlm}|j d||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 %s)r6zyNo callback with increment_callback_logging_failure method found for %s. Ensure 'prometheus' is in your callbacks config.z+Error in handle_callback_failure for %s: %s) r&litellm._loggingr logging_callback_manager_get_all_callbackshasattrdebugr8r?)r1r6r&r all_callbacks callback_objes r3handle_callback_failurez$CustomLogger.handle_callback_failures  b  7#*#C#C#V#V#XM -  <)MN(N(()VXef CCR_C`   !N L   b 7 N !NP]_` a a bs"5A4&A4A44 B!=BB!payloadr max_depthcK|jdg}t|tr|ng}tjdt ||r|j |||d<d}|jdgxsgD]D}t|ts|jdg}t|ts7|t |z }Ftjd||Swu 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. rNz0[CustomLogger] Stripping base64 from %s messages)rNrCrr!z@[CustomLogger] Completed base64 strip; retained %s content itemsr=r(rAr r=r_process_messagesr)r1rBrC raw_messagesrN total_itemsmr!s r3_strip_base64_from_messagesz(CustomLogger._strip_base64_from_messagess$+;;z2#> 5? d5S\Y[OQTU]Q^_ "&"8"8(V_"8"`GJ  Z,2 0A!T"%% 2.gt,3w</K  0 _almsB C "C/(Cc|jdg}t|tr|ng}tjdt ||r|j |||d<d}|jdgxsgD]D}t|ts|jdg}t|ts7|t |z }Ftjd||SrErFrHs r3 _strip_base64_from_messages_syncz-CustomLogger._strip_base64_from_messages_syncs$+;;z2#> 5? d5S\Y[OQTU]Q^_ "&"8"8(V_"8"`GJ  Z,2 0A!T"%% 2.gt,3w</K  0 _almr5rvaluedepthc ||kDrtjd|yt|trFtj |r/tj d|ddtjd|S|St|tr%|Dcgc]}|j||dz|c}St|tr9|jDcic]\}}||j||dz|c}}S|Scc}wcc}}w) z\Recursively redact inline base64 from any nested structure with a max recursion depth limit.zD[CustomLogger] Max recursion depth %s reached while redacting base64z[MAX_DEPTH_REACHED]z3[CustomLogger] Redacted inline base64 string: %s...N(z[BASE64_REDACTED])rOrPrC) r warningr(rr(searchr=subrA_redact_base64r)items)r1rOrPrCvks r3rWzCustomLogger._redact_base64!s 9   " "#ikt u( eS !%,,U3$$%Z\abece\fg-112EuMML eT "`ef[\D''auqyI'Vf f eT "fkfqfqfst^b^_abAt**%!)y*YYt t gus C3 "C8r!ct|tsyd|vry|jd}t|txr|dk7 S)z4Return True if this content item should be retained.TfileFtyper)r(r)r=r)r1r!ctypes r3_should_keep_contentz!CustomLogger._should_keep_content:sA'4( W {{6*uc*>u??r5cg}|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 )rOrC)r(r)r=rAr_appendrWrX) r1rNrCfiltered_messagesmsgcontentscleanedckeyvals r3rGzCustomLogger._process_messagesCs :< *Cc4(GGI.H(D)%'!ZA000;t':':i':'XYZ")I!%!4!48y!4!YI - SS)##22 2RCH S  $ $S )! *"! r5)FTrJ)rkr)NNNNFF)NNNFF)NNF)NN)i__name__ __module__ __qualname__ frozensetr+rr__annotations__r,boolr4 staticmethodrArHrOrVrXrZr\r^rbr)rdrgrirlrrrrinttuplerzr|rr%rrrrrrrrrrobjectr?rrrrrrrrr rrrrrrr!rrrr rrrrrrrrrrrrrr"rrrrrrrrrrr rrrr3r6rAr rLrNrWr_rGrKr5r3r*r*=s  V_bfVf korvkv  T TTX[ ]adh]h   $+   # t#  D  &* . c6k*. . t# . d .  . `      t#  t   " :=* NR  S RV lu  S RV lu  ;PSW;W  = YY]M]  !$ '$ .  H  H#94"? H t  H  )      $   C$%  2637 *  c3h$.   S>D0  c3h$ B%)   & *  Tz  / "  *  * #   tSSUZ[_ad[dUe4tUXyIY  * $    )    )  +T1 2  M M M M"$= "T )(888t* 8 DzD 8  8!88 tTz 8tC C C t* C  C -0 C 59C )C C C  C J777t* 7  7 -0 7597)777 7(  *  $   t*  DzD   !   tTz        t*      )         777t* 7  7  7)777 7$!7,q!7qq q  q, 3 C C  *TD[ *CRVJ *H'Z^H'cgH'T    bSb>I) " FI) " FH   2@C@D@I!s)!! d38n  !r5r*)=rercollections.abcrrtypingrrrrr pydanticr r9r rr "litellm.types.integrations.argillar(litellm.types.integrations.custom_loggerrlitellm.types.llms.openairr"litellm.types.prompts.init_promptsrlitellm.types.utilsrrrrrrrrrfastapiropentelemetry.tracer_Spanlitellm.caching.cachingr*litellm.litellm_core_utils.litellm_loggingr rr>r!litellm.types.mcpr"r#r$litellm.types.routerr%r&rmr'compile MULTILINEr(r*rKr5r3rs 3@@+M:DM9   %11W3 < 3;D DN #!"(++),, !+ VLL! ]!]!r5