hPddlmZddlmZmZmZmZmZmZmZm Z ddl m Z ddl m Z ddlmZddlmZmZmZmZmZddlmZddlmZmZmZe ZGd d eZd Zy ) )datetime)AnyDictListLiteralOptionalTypeUnionget_args)verbose_logger) DualCache) CustomLogger)DynamicGuardrailParamsGuardrailEventHooks LitellmParamsMode PiiEntityType)GuardrailConfigModel) CallTypesLLMResponseTypes#StandardLoggingGuardrailInformationceZdZ d2deedeeedeeeeeefde de de f fd Z e d ee d fd Z deeeeeefdeed dfd Zd ed eeeeeeefffdZdeeeeeeeffd e fdZdeeefdeed eefdZdededeed eefdZded e fdZded e fdZded efdZd e fdZ d3deeeeeefdededdeed eed!eed"eeee fd dfd#Z! d4d$ed%eed&eee"d efd'Z# d5deededeed eed!eef d(Z$ d5d)ededeed eed!eef d*Z%d+ed,ed-e d.e d ef d/Z&d0e'd dfd1Z(xZ)S)6CustomGuardrailNguardrail_namesupported_event_hooks event_hook default_onmask_request_contentmask_response_contentc ||_||_||_||_||_||_|r|j ||t| di|y)a8 Initialize the CustomGuardrail class Args: guardrail_name: The name of the guardrail. This is the name used in your requests. supported_event_hooks: The event hooks that the guardrail supports event_hook: The event hook to run the guardrail on default_on: If True, the guardrail will be run by default on all requests mask_request_content: If True, the guardrail will mask the request content mask_response_content: If True, the guardrail will mask the response content N) rrrrrr_validate_event_hooksuper__init__) selfrrrrrrkwargs __class__s a/var/www/Befach/backend/env/lib/python3.12/site-packages/litellm/integrations/custom_guardrail.pyr$zCustomGuardrail.__init__s`.-%:"  !+*>!+@"   % %j2G H "6"returnrcy)zx Returns the config model for the guardrail This is used to render the config model in the UI. Nr!r!r)r(get_config_modelz CustomGuardrail.get_config_model?sr)cdtttttfdttddfd}|yt |tr t|}t |t r |||yt |t rL|t |jj||jr||jg|yyt |tr||vrtd|d|yy)Nrrr*cr|D]2}t|tr t|}||vs#td|d|y)N Event hook % is not in the supported event hooks ) isinstancestrr ValueError)rrhooks r(5_validate_event_hook_list_is_in_supported_event_hookszcCustomGuardrail._validate_event_hook.._validate_event_hook_list_is_in_supported_event_hooksPsK#dC(.t4D44$%dV+PQfPgh #r)r/r0) r rrr2r1listrtagsvaluesdefaultr3)r%rrr5s r(r"z$CustomGuardrail._validate_event_hookHs d#67cBC #'(;#<      j# &,Z8J j$ ' A1  D ) AZ__++-.0E !!E''(*?" $7 8!66 !*-RShRij79r)datactd|vr|dS|jdxsi}|jdxsg}|r|S|S)zN Returns the guardrail(s) to be run from the metadata or root guardrailsmetadata)get)r%r:r=requested_guardrailss r(get_guardrail_from_metadataz+CustomGuardrail.get_guardrail_from_metadatarsM 4  % %88J'-2'||L9?R ' '##r)r?c|D]E}t|tr|j|vs"yt|ts5|j|k(sEyy)NTF)r1dictrr2)r%r? _guardrails r(%_guardrail_is_in_requested_guardrailsz5CustomGuardrail._guardrail_is_in_requested_guardrailssI /J*d+&&*4J,&&*4/r)r& call_typec \Kddlm}|jd}|t|ts|S|j |t jdur|S|tjk(s|tjk(r|j||jd|jd|jd|jd |jd  t||jxsd d{}|(t|tr|jd}|||d<|S70w)NrUserAPIKeyAuthr<r: event_typeTuser_api_key_user_iduser_api_key_team_iduser_api_key_end_user_iduser_api_key_hashuser_api_key_request_routeuser_idteam_id end_user_idapi_key request_route acompletion)user_api_key_dictcacher:rEmessages)litellm.proxy._typesrHr>r1r6should_run_guardrailrpre_callr completionrVasync_pre_call_hookdcvaluerB)r%r&rErHlitellm_guardrailsresultresult_messagess r(async_pre_call_deployment_hookz.CustomGuardrail.async_pre_call_deployment_hooks0 8$ZZ 5  %Z8JD-QM  % %(;(D(D &   M  ,, , Y=R=R0R33"0"JJ'=>"JJ'=> & +E F"JJ':;"(**-I"J ##//:]4  F!j&>"(**Z"8".)8F:& % sC7D,9D*:1D, request_dataresponsec Kddlm}|jd}|t|ts|S|j |t jdur|S|j||jd|jd|jd |jd |jd  || d{}|t|tts|S|S7#w)zh Allow modifying / reviewing the response just after it's received from the deployment. rrGr<NrITrKrLrMrNrOrP)rWr:rf) rZrHr>r1r6r[r post_callasync_post_call_success_hookr r)r%rerfrErHrarbs r('async_post_call_success_deployment_hookz7CustomGuardrail.async_post_call_success_deployment_hooks 8*--l;  %Z8JD-QO  % %!.A.K.K &   O88,$(()?@$(()?@(,,-GH$(()<=*../KL 9    >FH=M4N!OO   sB>C&C$$C&rJc|j|}tjd|j||j||j |j durT|j |rBt|jtr' ddl m }|j||j}||Syy|jr!|j|s|jdk7ry|j |syt|jtr' ddl m }|j||j}||Sy#t$r tdwxYw#t$r tdwxYw)zO Returns True if the guardrail should be run on the event_type zinside should_run_guardrail for guardrail=%s event_type= %s guardrail_supported_event_hooks= %s requested_guardrails= %s self.default_on= %sTr)EnterpriseCustomGuardrailHelperzuSetting tag-based guardrails is only available in litellm-enterprise. You must be a premium user to use this feature.F logging_only)r@r debugrrr_event_hook_is_event_typer1r0litellm_enterprise.integrations.custom_guardrailrl ImportError_should_run_if_mode_by_tagrDr`)r%r:rJr?rlrbs r(r[z$CustomGuardrail.should_run_guardrailsm $??E [     OO OO   ??d "--j9doot4=WWdooF)%  OO>>?ST  N2--j9 doot , 5OOdooF! K')T6 !L sD-E-EEcF|jyt|jtr|j|jvSt|jtr0|j|jj j vS|j|jk(S)a Returns True if the event_hook is the same as the event_type eg. if `self.event_hook == "pre_call" and event_type == "pre_call"` -> then True eg. if `self.event_hook == "pre_call" and event_type == "post_call"` -> then False T)rr1r6r`rr7r8)r%rJs r(roz)CustomGuardrail._event_hook_is_event_type%s{ ?? " doot ,##t6 6 doot ,##t';';'B'B'DD D*"2"222r)c|j|}|D]c}t|ts|j|vs#t di||j}|j duricS|j dicSiS)a Returns `extra_body` to be added to the request body for the Guardrail API call Use this to pass dynamic params to the guardrail API call - eg. success_threshold, failure_threshold, etc. ``` [{"lakera_guard": {"extra_body": {"foo": "bar"}}}] ``` Will return: for guardrail=`lakera-guard`: { "foo": "bar" } Args: request_data: The original `request_data` passed to LiteLLM Proxy T extra_bodyr!)r@r1rBrr_validate_premium_userr>)r%rer? guardrailguardrail_configs r()get_guardrail_dynamic_request_body_paramsz9CustomGuardrail.get_guardrail_dynamic_request_body_params5s$ $?? M.I)T*t/B/Bi/O;Q< 3 34< ..0<I(++L"==. r)cvddlm}m}|dur-tjd|j j yy)z< Returns True if the user is a premium user r)CommonProxyErrors premium_userTz5Trying to use premium guardrail without premium user F)litellm.proxy.proxy_serverr{r|r warningnot_premium_userr`)r%r{r|s r(rvz&CustomGuardrail._validate_premium_userXs> O t #  " "GHYHjHjHpHpGqr r)guardrail_json_responseguardrail_status)successfailure start_timeend_timedurationmasked_entity_countc zt|tr t|}ddlm}t |j t|jtr |d i|jjn |j||||||} d|vr|di|d<| |dd<yd|vr | |dd<ytjdy) z Builds `StandardLoggingGuardrailInformation` and adds it to the request metadata so it can be used for logging to DataDog, Langfuse, etc. r) GuardrailMode)rguardrail_modeguardrail_responserrrrrr=N&standard_logging_guardrail_informationlitellm_metadatazFunable to log guardrail information. No metadata found in request_datar!) r1 Exceptionr2litellm.types.utilsrrrrr model_dumpr r~) r%rrerrrrrrslgs r(:add_standard_logging_guardrail_information_to_request_datazJCustomGuardrail.add_standard_logging_guardrail_information_to_request_dataes -y 9&)*A&B #51..doot4= : : <=__6-! 3    %J'/+- Z(QTL $%M N < / + ,8   " "X r)textlanguageentitiescK|Sw)a Apply your guardrail logic to the given text Args: text: The text to apply the guardrail to language: The language of the text entities: The entities to mask, optional Any of the custom guardrails can override this method to provide custom guardrail logic Returns the text with the guardrail applied Raises: Exception: - If the guardrail raises an exception r!)r%rrrs r(apply_guardrailzCustomGuardrail.apply_guardrails . sc@|in|}|j||d||||S) Add StandardLoggingGuardrailInformation to the request data This gets logged on downsteam Langfuse, DataDog, etc. rrrerrrrr)r%rfrerrrrs r(_process_responsez!CustomGuardrail._process_responses>$,#3R GG$6%&! H r)ec4|j||d||||)rrrr)r%rrerrrs r(_process_errorzCustomGuardrail._process_errors1 GG$%%&! H r)content_string mask_string start_index end_indexc\d|cxkr|cxkrt|ks|S|S|d||z||dzS)zS Mask the content in the string between the start and end indices. rN)len)r%rrrrs r(mask_content_in_stringz&CustomGuardrail.mask_content_in_stringsM[C9CN0CC! !D! !l{+k9N9:T9T4U/V$VW "'38n'19)1D' $'R((#(I& ( " # (T?(?  ?B34G3D3 !d!t!F  $'+$($(8<*!&y#tT$Z'G!H**""67 * UO * 5/ *5/*&d38n5* *^#'26 3-4 ./  :'+$($( 4.UO  5/  5/ :'+$($(  UO  5/  5/ .WWW W  W W$ m PT r)rcddlddl}|jfd|jfd|jfd}|S)ad Decorator to add standard logging guardrail information to any function Add this decorator to ensure your guardrail response is logged to DataDog, OTEL, s3, GCS etc. Logs for: - pre_call - during_call - TODO: log post_call. This is more involved since the logs are sent to DD, s3 before the guardrail is even run rNc |Ktj}|d}|jdxs|jdxsi} |i|d{}|j|||j tjj tj|z j S7k#t $rq}|j|||j tjj tj|z j cYd}~Sd}~wwxYww)Nrr:re)rfrerrr)rrerrr)rnowr>r timestamp total_secondsrrargsr&rr%rerfrfuncs r( async_wrapperz0log_guardrail_information..async_wrappers\\^ $Q#ZZ/S6::n3MSQS  !42622H))!)%//1!113",,.:5DDF * 3 &&)%//1!113",,.:5DDF '  sJAD< B?B=A*B?<D<=B?? D9A&D4.D9/D<4D99D<ctj}|d}|jdxs|jdxsi} |i|}|j||tj|z j S#t $rA}|j ||tj|z j cYd}~Sd}~wwxYw)Nrr:re)rfrer)rrer)rrr>rrrrrs r( sync_wrapperz/log_guardrail_information..sync_wrappers\\^ $Q#ZZ/S6::n3MSQS  T,V,H))!)",,.:5DDF*   &&)",,.:5DDF'  s>B C  6CC C cFjr|i|S|i|S)N)iscoroutinefunction)rr&rasynciorrs r(wrapperz*log_guardrail_information..wrapper+s1  & &t , $1&1 1T,V,,r))r functoolswraps)rrrrrrs` @@@r(log_guardrail_informationrsg__T,__T$__T-- Nr)N)rtypingrrrrrr r r litellm._loggingr litellm.cachingr "litellm.integrations.custom_loggerrlitellm.types.guardrailsrrrrr3litellm.types.proxy.guardrails.guardrail_hooks.baserrrrrr_rrr!r)r(rsQLLL+%;U [X lX v>r)