litellm-enterprise 0.1.25__py3-none-any.whl → 0.1.27__py3-none-any.whl

litellm_enterprise/enterprise_callbacks/send_emails/base_email.py

@@ -5,7 +5,7 @@ Base class for sending emails to user after creating keys or invite links
 
 import json
 import os
-from typing import List, Optional
+from typing import List, Literal, Optional
 
 from litellm_enterprise.types.enterprise_callbacks.send_emails import (
     EmailEvent,
@@ -15,6 +15,7 @@ from litellm_enterprise.types.enterprise_callbacks.send_emails import (
 )
 
 from litellm._logging import verbose_proxy_logger
+from litellm.caching.caching import DualCache
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.integrations.email_templates.email_footer import EMAIL_FOOTER
 from litellm.integrations.email_templates.key_created_email import (
@@ -26,9 +27,17 @@ from litellm.integrations.email_templates.key_rotated_email import (
 from litellm.integrations.email_templates.user_invitation_email import (
     USER_INVITATION_EMAIL_TEMPLATE,
 )
-from litellm.proxy._types import InvitationNew, UserAPIKeyAuth, WebhookEvent
+from litellm.integrations.email_templates.templates import (
+    MAX_BUDGET_ALERT_EMAIL_TEMPLATE,
+    SOFT_BUDGET_ALERT_EMAIL_TEMPLATE,
+)
+from litellm.proxy._types import CallInfo, InvitationNew, UserAPIKeyAuth, WebhookEvent
 from litellm.secret_managers.main import get_secret_bool
 from litellm.types.integrations.slack_alerting import LITELLM_LOGO_URL
+from litellm.constants import (
+    EMAIL_BUDGET_ALERT_MAX_SPEND_ALERT_PERCENTAGE,
+    EMAIL_BUDGET_ALERT_TTL,
+)
 
 
 class BaseEmailLogger(CustomLogger):
@@ -40,6 +49,21 @@ class BaseEmailLogger(CustomLogger):
         EmailEvent.virtual_key_rotated: "LiteLLM: {event_message}",
     }
 
+    def __init__(
+        self,
+        internal_usage_cache: Optional[DualCache] = None,
+        **kwargs,
+    ):
+        """
+        Initialize BaseEmailLogger
+
+        Args:
+            internal_usage_cache: DualCache instance for preventing duplicate alerts
+            **kwargs: Additional arguments passed to CustomLogger
+        """
+        super().__init__(**kwargs)
+        self.internal_usage_cache = internal_usage_cache or DualCache()
+
     async def send_user_invitation_email(self, event: WebhookEvent):
         """
         Send email to user after inviting them to the team
@@ -154,6 +178,216 @@ class BaseEmailLogger(CustomLogger):
         )
         pass
 
+    async def send_soft_budget_alert_email(self, event: WebhookEvent):
+        """
+        Send email to user when soft budget is crossed
+        """
+        email_params = await self._get_email_params(
+            email_event=EmailEvent.soft_budget_crossed,  # Reuse existing event type for subject template
+            user_id=event.user_id,
+            user_email=event.user_email,
+            event_message=event.event_message,
+        )
+
+        verbose_proxy_logger.debug(
+            f"send_soft_budget_alert_email_event: {json.dumps(event.model_dump(exclude_none=True), indent=4, default=str)}"
+        )
+
+        # Format budget values
+        soft_budget_str = f"${event.soft_budget}" if event.soft_budget is not None else "N/A"
+        spend_str = f"${event.spend}" if event.spend is not None else "$0.00"
+        max_budget_info = ""
+        if event.max_budget is not None:
+            max_budget_info = f"<b>Maximum Budget:</b> ${event.max_budget} <br />"
+
+        email_html_content = SOFT_BUDGET_ALERT_EMAIL_TEMPLATE.format(
+            email_logo_url=email_params.logo_url,
+            recipient_email=email_params.recipient_email,
+            soft_budget=soft_budget_str,
+            spend=spend_str,
+            max_budget_info=max_budget_info,
+            base_url=email_params.base_url,
+            email_support_contact=email_params.support_contact,
+        )
+        await self.send_email(
+            from_email=self.DEFAULT_LITELLM_EMAIL,
+            to_email=[email_params.recipient_email],
+            subject=email_params.subject,
+            html_body=email_html_content,
+        )
+        pass
+
+    async def send_max_budget_alert_email(self, event: WebhookEvent):
+        """
+        Send email to user when max budget alert threshold is reached
+        """
+        email_params = await self._get_email_params(
+            email_event=EmailEvent.max_budget_alert,
+            user_id=event.user_id,
+            user_email=event.user_email,
+            event_message=event.event_message,
+        )
+
+        verbose_proxy_logger.debug(
+            f"send_max_budget_alert_email_event: {json.dumps(event.model_dump(exclude_none=True), indent=4, default=str)}"
+        )
+
+        # Format budget values
+        spend_str = f"${event.spend}" if event.spend is not None else "$0.00"
+        max_budget_str = f"${event.max_budget}" if event.max_budget is not None else "N/A"
+        
+        # Calculate percentage and alert threshold
+        percentage = int(EMAIL_BUDGET_ALERT_MAX_SPEND_ALERT_PERCENTAGE * 100)
+        alert_threshold_str = f"${event.max_budget * EMAIL_BUDGET_ALERT_MAX_SPEND_ALERT_PERCENTAGE:.2f}" if event.max_budget is not None else "N/A"
+
+        email_html_content = MAX_BUDGET_ALERT_EMAIL_TEMPLATE.format(
+            email_logo_url=email_params.logo_url,
+            recipient_email=email_params.recipient_email,
+            percentage=percentage,
+            spend=spend_str,
+            max_budget=max_budget_str,
+            alert_threshold=alert_threshold_str,
+            base_url=email_params.base_url,
+            email_support_contact=email_params.support_contact,
+        )
+        await self.send_email(
+            from_email=self.DEFAULT_LITELLM_EMAIL,
+            to_email=[email_params.recipient_email],
+            subject=email_params.subject,
+            html_body=email_html_content,
+        )
+        pass
+
+    async def budget_alerts(
+        self,
+        type: Literal[
+            "token_budget",
+            "soft_budget",
+            "max_budget_alert",
+            "user_budget",
+            "team_budget",
+            "organization_budget",
+            "proxy_budget",
+            "projected_limit_exceeded",
+        ],
+        user_info: CallInfo,
+    ):
+        """
+        Send a budget alert via email
+
+        Args:
+            type: The type of budget alert to send
+            user_info: The user info to send the alert for
+        """
+        ## PREVENTITIVE ALERTING ##
+        # - Alert once within 24hr period
+        # - Cache this information
+        # - Don't re-alert, if alert already sent
+        _cache: DualCache = self.internal_usage_cache
+
+        # percent of max_budget left to spend
+        if user_info.max_budget is None and user_info.soft_budget is None:
+            return
+
+        # For soft_budget alerts, check if we've already sent an alert
+        if type == "soft_budget":
+            if user_info.soft_budget is not None and user_info.spend >= user_info.soft_budget:
+                # Generate cache key based on event type and identifier
+                _id = user_info.token or user_info.user_id or "default_id"
+                _cache_key = f"email_budget_alerts:soft_budget_crossed:{_id}"
+                
+                # Check if we've already sent this alert
+                result = await _cache.async_get_cache(key=_cache_key)
+                if result is None:
+                    # Create WebhookEvent for soft budget alert
+                    event_message = f"Soft Budget Crossed - Total Soft Budget: ${user_info.soft_budget}"
+                    webhook_event = WebhookEvent(
+                        event="soft_budget_crossed",
+                        event_message=event_message,
+                        spend=user_info.spend,
+                        max_budget=user_info.max_budget,
+                        soft_budget=user_info.soft_budget,
+                        token=user_info.token,
+                        customer_id=user_info.customer_id,
+                        user_id=user_info.user_id,
+                        team_id=user_info.team_id,
+                        team_alias=user_info.team_alias,
+                        organization_id=user_info.organization_id,
+                        user_email=user_info.user_email,
+                        key_alias=user_info.key_alias,
+                        projected_exceeded_date=user_info.projected_exceeded_date,
+                        projected_spend=user_info.projected_spend,
+                        event_group=user_info.event_group,
+                    )
+                    
+                    try:
+                        await self.send_soft_budget_alert_email(webhook_event)
+                        
+                        # Cache the alert to prevent duplicate sends
+                        await _cache.async_set_cache(
+                            key=_cache_key,
+                            value="SENT",
+                            ttl=EMAIL_BUDGET_ALERT_TTL,
+                        )
+                    except Exception as e:
+                        verbose_proxy_logger.error(
+                            f"Error sending soft budget alert email: {e}",
+                            exc_info=True,
+                        )
+            return
+
+        # For max_budget_alert, check if we've already sent an alert
+        if type == "max_budget_alert":
+            if user_info.max_budget is not None and user_info.spend is not None:
+                alert_threshold = user_info.max_budget * EMAIL_BUDGET_ALERT_MAX_SPEND_ALERT_PERCENTAGE
+                # Only alert if we've crossed the threshold but haven't exceeded max_budget yet
+                if user_info.spend >= alert_threshold and user_info.spend < user_info.max_budget:
+                    # Generate cache key based on event type and identifier
+                    _id = user_info.token or user_info.user_id or "default_id"
+                    _cache_key = f"email_budget_alerts:max_budget_alert:{_id}"
+                    # Check if we've already sent this alert
+                    result = await _cache.async_get_cache(key=_cache_key)
+                    if result is None:
+                        # Calculate percentage
+                        percentage = int(EMAIL_BUDGET_ALERT_MAX_SPEND_ALERT_PERCENTAGE * 100)
+                        
+                        # Create WebhookEvent for max budget alert
+                        event_message = f"Max Budget Alert - {percentage}% of Maximum Budget Reached"
+                        webhook_event = WebhookEvent(
+                            event="max_budget_alert",
+                            event_message=event_message,
+                            spend=user_info.spend,
+                            max_budget=user_info.max_budget,
+                            soft_budget=user_info.soft_budget,
+                            token=user_info.token,
+                            customer_id=user_info.customer_id,
+                            user_id=user_info.user_id,
+                            team_id=user_info.team_id,
+                            team_alias=user_info.team_alias,
+                            organization_id=user_info.organization_id,
+                            user_email=user_info.user_email,
+                            key_alias=user_info.key_alias,
+                            projected_exceeded_date=user_info.projected_exceeded_date,
+                            projected_spend=user_info.projected_spend,
+                            event_group=user_info.event_group,
+                        )
+                        
+                        try:
+                            await self.send_max_budget_alert_email(webhook_event)
+                            
+                            # Cache the alert to prevent duplicate sends
+                            await _cache.async_set_cache(
+                                key=_cache_key,
+                                value="SENT",
+                                ttl=EMAIL_BUDGET_ALERT_TTL,
+                            )
+                        except Exception as e:
+                            verbose_proxy_logger.error(
+                                f"Error sending max budget alert email: {e}",
+                                exc_info=True,
+                            )
+            return
+
     async def _get_email_params(
         self,
         email_event: EmailEvent,

litellm_enterprise/enterprise_callbacks/send_emails/resend_email.py

@@ -19,7 +19,8 @@ RESEND_API_ENDPOINT = "https://api.resend.com/emails"
 
 
 class ResendEmailLogger(BaseEmailLogger):
-    def __init__(self):
+    def __init__(self, internal_usage_cache=None, **kwargs):
+        super().__init__(internal_usage_cache=internal_usage_cache, **kwargs)
         self.async_httpx_client = get_async_httpx_client(
             llm_provider=httpxSpecialProvider.LoggingCallback
         )

litellm_enterprise/enterprise_callbacks/send_emails/sendgrid_email.py

@@ -27,7 +27,8 @@ class SendGridEmailLogger(BaseEmailLogger):
     - SENDGRID_API_KEY
     """
 
-    def __init__(self):
+    def __init__(self, internal_usage_cache=None, **kwargs):
+        super().__init__(internal_usage_cache=internal_usage_cache, **kwargs)
         self.async_httpx_client = get_async_httpx_client(
             llm_provider=httpxSpecialProvider.LoggingCallback
         )

litellm_enterprise/enterprise_callbacks/send_emails/smtp_email.py

@@ -21,7 +21,8 @@ class SMTPEmailLogger(BaseEmailLogger):
     - SMTP_SENDER_EMAIL
     """
 
-    def __init__(self):
+    def __init__(self, internal_usage_cache=None, **kwargs):
+        super().__init__(internal_usage_cache=internal_usage_cache, **kwargs)
         verbose_logger.debug("SMTP Email Logger initialized....")
 
     async def send_email(

litellm_enterprise/proxy/hooks/managed_files.py

@@ -22,7 +22,6 @@ from litellm.proxy._types import (
 )
 from litellm.proxy.openai_files_endpoints.common_utils import (
     _is_base64_encoded_unified_file_id,
-    convert_b64_uid_to_unified_uid,
     get_batch_id_from_unified_batch_id,
     get_model_id_from_unified_batch_id,
 )
@@ -42,6 +41,10 @@ from litellm.types.utils import (
     LLMResponseTypes,
     SpecialEnums,
 )
+from litellm.proxy.openai_files_endpoints.common_utils import (
+    get_content_type_from_file_object,
+    normalize_mime_type_for_provider,
+)
 
 if TYPE_CHECKING:
     from litellm.types.llms.openai import HttpxBinaryResponseContent
@@ -108,6 +111,17 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
 
         if file_object is not None:
             db_data["file_object"] = file_object.model_dump_json()
+            # Extract storage metadata from hidden params if present
+            hidden_params = getattr(file_object, "_hidden_params", {}) or {}
+            if "storage_backend" in hidden_params:
+                db_data["storage_backend"] = hidden_params["storage_backend"]
+            if "storage_url" in hidden_params:
+                db_data["storage_url"] = hidden_params["storage_url"]
+            
+            verbose_logger.debug(
+                f"Storage metadata: storage_backend={db_data.get('storage_backend')}, "
+                f"storage_url={db_data.get('storage_url')}"
+            )
 
         result = await self.prisma_client.db.litellm_managedfiletable.create(
             data=db_data
@@ -268,7 +282,7 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
                 )
         return False
 
-    async def async_pre_call_hook(
+    async def async_pre_call_hook(  # noqa: PLR0915
         self,
         user_api_key_dict: UserAPIKeyAuth,
         cache: DualCache,
@@ -287,15 +301,31 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
             await self.check_managed_file_id_access(data, user_api_key_dict)
 
         ### HANDLE TRANSFORMATIONS ###
-        if call_type == CallTypes.completion.value:
+        # Check both completion and acompletion call types
+        is_completion_call = (
+            call_type == CallTypes.completion.value 
+            or call_type == CallTypes.acompletion.value
+        )
+        
+        if is_completion_call:
             messages = data.get("messages")
+            model = data.get("model", "")
             if messages:
                 file_ids = self.get_file_ids_from_messages(messages)
                 if file_ids:
+                    # Check if any files are stored in storage backends and need base64 conversion
+                    # This is needed for Vertex AI/Gemini which requires base64 content
+                    is_vertex_ai = model and ("vertex_ai" in model or "gemini" in model.lower())
+                    if is_vertex_ai:
+                        await self._convert_storage_files_to_base64(
+                            messages=messages,
+                            file_ids=file_ids,
+                            litellm_parent_otel_span=user_api_key_dict.parent_otel_span,
+                        )
+                    
                     model_file_id_mapping = await self.get_model_file_id_mapping(
                         file_ids, user_api_key_dict.parent_otel_span
                     )
-
                     data["model_file_id_mapping"] = model_file_id_mapping
         elif call_type == CallTypes.aresponses.value or call_type == CallTypes.responses.value:
             # Handle managed files in responses API input
@@ -720,9 +750,27 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
                         model_id=model_id,
                         model_name=model_name,
                     )
-                    await self.store_unified_file_id(  # need to store otherwise any retrieve call will fail
+                    
+                    # Fetch the actual file object for the output file
+                    file_object = None
+                    try:
+                        # Use litellm to retrieve the file object from the provider
+                        from litellm import afile_retrieve
+                        file_object = await afile_retrieve(
+                            custom_llm_provider=model_name.split("/")[0] if model_name and "/" in model_name else "openai",
+                            file_id=original_output_file_id
+                        )
+                        verbose_logger.debug(
+                            f"Successfully retrieved file object for output_file_id={original_output_file_id}"
+                        )
+                    except Exception as e:
+                        verbose_logger.warning(
+                            f"Failed to retrieve file object for output_file_id={original_output_file_id}: {str(e)}. Storing with None and will fetch on-demand."
+                        )
+                    
+                    await self.store_unified_file_id(
                         file_id=response.output_file_id,
-                        file_object=None,
+                        file_object=file_object,
                         litellm_parent_otel_span=user_api_key_dict.parent_otel_span,
                         model_mappings={model_id: original_output_file_id},
                         user_api_key_dict=user_api_key_dict,
@@ -865,3 +913,124 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
             )
         else:
             raise Exception(f"LiteLLM Managed File object with id={file_id} not found")
+
+    async def _convert_storage_files_to_base64(
+        self,
+        messages: List[AllMessageValues],
+        file_ids: List[str],
+        litellm_parent_otel_span: Optional[Span],
+    ) -> None:
+        """
+        Convert files stored in storage backends to base64 format for Vertex AI/Gemini.
+        
+        This method checks if any managed files are stored in storage backends,
+        downloads them, and converts them to base64 format in the messages.
+        """
+        # Check each file_id to see if it's stored in a storage backend
+        for file_id in file_ids:
+            # Check if this is a base64 encoded unified file ID
+            decoded_unified_file_id = _is_base64_encoded_unified_file_id(file_id)
+            
+            if not decoded_unified_file_id:
+                continue
+            
+            # Check database for storage backend info
+            # IMPORTANT: The database stores the base64 encoded unified_file_id (not the decoded version)
+            # So we query with the original file_id (which is base64 encoded)
+            db_file = await self.prisma_client.db.litellm_managedfiletable.find_first(
+                where={"unified_file_id": file_id}
+            )
+            
+            if not db_file or not db_file.storage_backend or not db_file.storage_url:
+                continue
+            
+            # File is stored in a storage backend, download and convert to base64
+            try:
+                from litellm.llms.base_llm.files.storage_backend_factory import get_storage_backend
+                
+                storage_backend_name = db_file.storage_backend
+                storage_url = db_file.storage_url
+                
+                # Get storage backend (uses same env vars as callback)
+                try:
+                    storage_backend = get_storage_backend(storage_backend_name)
+                except ValueError as e:
+                    verbose_logger.warning(
+                        f"Storage backend '{storage_backend_name}' error for file {file_id}: {str(e)}"
+                    )
+                    continue
+                
+                file_content = await storage_backend.download_file(storage_url)
+                
+                # Determine content type from file object
+                content_type = self._get_content_type_from_file_object(db_file.file_object)
+                
+                # Convert to base64
+                base64_data = base64.b64encode(file_content).decode("utf-8")
+                base64_data_uri = f"data:{content_type};base64,{base64_data}"
+                
+                # Update messages to use base64 instead of file_id
+                self._update_messages_with_base64_data(messages, file_id, base64_data_uri, content_type)
+            except Exception as e:
+                verbose_logger.exception(
+                    f"Error converting file {file_id} from storage backend to base64: {str(e)}"
+                )
+                # Continue with other files even if one fails
+                continue
+
+    def _get_content_type_from_file_object(self, file_object: Optional[Any]) -> str:
+        """
+        Determine content type from file object.
+        
+        Uses the MIME type utility for consistent detection and normalization.
+        
+        Args:
+            file_object: The file object from the database (can be dict, JSON string, or None)
+        
+        Returns:
+            str: MIME type (defaults to "application/octet-stream" if cannot be determined)
+        """
+        # Use utility function for detection
+        content_type = get_content_type_from_file_object(file_object)
+        
+        # Normalize for Gemini/Vertex AI (requires image/jpeg, not image/jpg)
+        content_type = normalize_mime_type_for_provider(content_type, provider="gemini")
+        
+        return content_type
+
+    def _update_messages_with_base64_data(
+        self,
+        messages: List[AllMessageValues],
+        file_id: str,
+        base64_data_uri: str,
+        content_type: str,
+    ) -> None:
+        """
+        Update messages to replace file_id with base64 data URI.
+        
+        Args:
+            messages: List of messages to update
+            file_id: The file ID to replace
+            base64_data_uri: The base64 data URI to use as replacement
+            content_type: The MIME type of the file (e.g., "image/jpeg", "application/pdf")
+        """
+        for message in messages:
+            if message.get("role") == "user":
+                content = message.get("content")
+                if content and isinstance(content, list):
+                    for element in content:
+                        if element.get("type") == "file":
+                            file_element = cast(ChatCompletionFileObject, element)
+                            file_element_file = file_element.get("file", {})
+                            
+                            if file_element_file.get("file_id") == file_id:
+                                # Replace file_id with base64 data
+                                file_element_file["file_data"] = base64_data_uri
+                                # Set format to help Gemini determine mime type
+                                file_element_file["format"] = content_type
+                                # Remove file_id to ensure only file_data is used
+                                file_element_file.pop("file_id", None)
+                                
+                                verbose_logger.debug(
+                                    f"Converted file {file_id} from storage backend to base64 with format {content_type}"
+                                )

litellm_enterprise/types/enterprise_callbacks/send_emails.py

@@ -36,6 +36,8 @@ class EmailEvent(str, enum.Enum):
     virtual_key_created = "Virtual Key Created"
     new_user_invitation = "New User Invitation"
     virtual_key_rotated = "Virtual Key Rotated"
+    soft_budget_crossed = "Soft Budget Crossed"
+    max_budget_alert = "Max Budget Alert"
 
 class EmailEventSettings(BaseModel):
     event: EmailEvent
@@ -51,6 +53,8 @@ class DefaultEmailSettings(BaseModel):
             EmailEvent.virtual_key_created: True,  # On by default
             EmailEvent.new_user_invitation: True,  # On by default
             EmailEvent.virtual_key_rotated: True,  # On by default
+            EmailEvent.soft_budget_crossed: True,  # On by default
+            EmailEvent.max_budget_alert: True,  # On by default
         }
     )
     def to_dict(self) -> Dict[str, bool]:

{litellm_enterprise-0.1.25.dist-info → litellm_enterprise-0.1.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: litellm-enterprise
-Version: 0.1.25
+Version: 0.1.27
 Summary: Package for LiteLLM Enterprise features
 License-File: LICENSE.md
 Author: BerriAI

{litellm_enterprise-0.1.25.dist-info → litellm_enterprise-0.1.27.dist-info}/RECORD

@@ -99,11 +99,11 @@ litellm_enterprise/enterprise_callbacks/secrets_plugins/typeform_api_token.py,sh
 litellm_enterprise/enterprise_callbacks/secrets_plugins/vault.py,sha256=fqtHTQTC6QaNMIZpuvntBnCSAgAhY2Ka-XOz4ZLafGk,653
 litellm_enterprise/enterprise_callbacks/secrets_plugins/yandex.py,sha256=BVtFVzCTtpAkRJVudeZIEBBz1W8wueDzpu6TBvxngxo,1183
 litellm_enterprise/enterprise_callbacks/secrets_plugins/zendesk_secret_key.py,sha256=3E21lWz12WUAmdnKDZH8znfTp6hRJbE3yImtfEP52qE,613
-litellm_enterprise/enterprise_callbacks/send_emails/base_email.py,sha256=w4omD5Z7gMZABxn7DmAlOiCX6f7VwJ1KMKq_NXpdkLc,15523
+litellm_enterprise/enterprise_callbacks/send_emails/base_email.py,sha256=qcY2oBDP9-30OTZF9bxPiXytgosUcGN5WGhKqSXTLE8,26083
 litellm_enterprise/enterprise_callbacks/send_emails/endpoints.py,sha256=hOEpM_q8MJAXlKMOtC9KbgvDVr_YFtF3reu9bjXkpsI,7017
-litellm_enterprise/enterprise_callbacks/send_emails/resend_email.py,sha256=lLG9W2hEOjn7lvMDKoaZGVCzr72HfreJuScMNOkE7FQ,1426
-litellm_enterprise/enterprise_callbacks/send_emails/sendgrid_email.py,sha256=_mHj-gBQlt1c-AUa5QPkVdCaM-ZIF7VolZFl6NKNHgc,2203
-litellm_enterprise/enterprise_callbacks/send_emails/smtp_email.py,sha256=_K3vGhyALVJWIzIk2oiHQbQPlYARdpPe-GA9hdl0vTg,1130
+litellm_enterprise/enterprise_callbacks/send_emails/resend_email.py,sha256=KxNfvONZxSWbNg0HmWwfC0rvHzpN7MBJXAPKGLcy_tU,1541
+litellm_enterprise/enterprise_callbacks/send_emails/sendgrid_email.py,sha256=4bvSOfV-WzCGIJX2V32Ug91I8GBQAmypDDp40qsZbQU,2318
+litellm_enterprise/enterprise_callbacks/send_emails/smtp_email.py,sha256=CGXmT-7EwftreMQXqUL7OC-XSh0cOje4s16Ptt9wBxc,1245
 litellm_enterprise/integrations/custom_guardrail.py,sha256=ZLVpqUZq9bR0vEFqVrlTJk0bYCZuFsXlw9XsdyK9t2E,1555
 litellm_enterprise/litellm_core_utils/litellm_logging.py,sha256=BKkQLPqebFbN-KeCbipGIPgdxHEfQkczImdhhzxKoFg,868
 litellm_enterprise/proxy/audit_logging_endpoints.py,sha256=BnHczmi4bnW1GpMNsq4CvnbwL3rgQ-pnrtFd5WBbbHY,5304
@@ -113,7 +113,7 @@ litellm_enterprise/proxy/auth/route_checks.py,sha256=FbXwbrOkFr1dODH6XxoIpLG1nKo
 litellm_enterprise/proxy/auth/user_api_key_auth.py,sha256=7t5Q-JoKFyoymylaOT8KWAAOFVz0JOTl7PPOmTkpj5c,1144
 litellm_enterprise/proxy/common_utils/check_batch_cost.py,sha256=V0CCHtN-JV-_d-ydXV-cVs3zCImt1699JnICGF3oPOk,7360
 litellm_enterprise/proxy/enterprise_routes.py,sha256=ToJVSSNaYUotzgIg-kWsfsqh2E0GnQirOPkpE4YkHNg,907
-litellm_enterprise/proxy/hooks/managed_files.py,sha256=n8_HsBFr7YmiJqTHMISTlJNo_3TxZ9AEwk0Bxcpa4_k,34228
+litellm_enterprise/proxy/hooks/managed_files.py,sha256=214MTFrwYs3yrAW84SNp-K8zYBZ9Ck2nkysKnLZjLAQ,42484
 litellm_enterprise/proxy/management_endpoints/__init__.py,sha256=zfaqryxzmFu6se-w4yR2nlHKxDOOtHAWEehA2xFbFNg,270
 litellm_enterprise/proxy/management_endpoints/internal_user_endpoints.py,sha256=GEoOVujrtKXDHfko2KQaLn-ms64zkutFE9PP5IhBBLM,2175
 litellm_enterprise/proxy/management_endpoints/key_management_endpoints.py,sha256=-IXRzVrNQ3_krL-gxngelYQftwyPlB_HmgI3RN-HdvM,1147
@@ -121,10 +121,10 @@ litellm_enterprise/proxy/proxy_server.py,sha256=fzOeTyiyevLWi2767-2W1Co7reR-0wno
 litellm_enterprise/proxy/readme.md,sha256=ZcigMJYSHWs4SWnYriWjrSVDJKsu44c2HsbYbma0EHU,397
 litellm_enterprise/proxy/utils.py,sha256=y4ADfhlEG_mH0x5rfIg7D9FjS586lVgQ9DL0tTdgrMQ,962
 litellm_enterprise/proxy/vector_stores/endpoints.py,sha256=6Guh6zIH00dh2XXStn6GblTGpGyE4hZJ9WThVZggDQg,12944
-litellm_enterprise/types/enterprise_callbacks/send_emails.py,sha256=XLhpdGvBFxPkV7hcgQ1gELVF0vTs5d2LLOoXPzjr4K4,1929
+litellm_enterprise/types/enterprise_callbacks/send_emails.py,sha256=AouBXqb1EB1-Mg3fM_3UjUDihIA45zIjRgA6M4vQ7Zw,2150
 litellm_enterprise/types/proxy/audit_logging_endpoints.py,sha256=oSJVAuRD9r6ZjRCqNBFM-J5HSgOltsXts400b2aynRE,894
 litellm_enterprise/types/proxy/proxy_server.py,sha256=kdhtxsU2uok6-XO_ebugCv7PzYYmGgv4vh-XemHJnpM,146
-litellm_enterprise-0.1.25.dist-info/METADATA,sha256=7dqFeGY5D-oaWqwJsbvkaGKcC73bWpo9qc-Y4ugmjtg,1441
-litellm_enterprise-0.1.25.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-litellm_enterprise-0.1.25.dist-info/licenses/LICENSE.md,sha256=nq3D9ZqOvRDT6hLkypQFTc3XsE15kbkg5rkkLJVSqKY,2251
-litellm_enterprise-0.1.25.dist-info/RECORD,,
+litellm_enterprise-0.1.27.dist-info/METADATA,sha256=NOumHWDgf-L-MMKoA9gCgEweLGji6O8_DMpB-Wa7TIE,1441
+litellm_enterprise-0.1.27.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+litellm_enterprise-0.1.27.dist-info/licenses/LICENSE.md,sha256=nq3D9ZqOvRDT6hLkypQFTc3XsE15kbkg5rkkLJVSqKY,2251
+litellm_enterprise-0.1.27.dist-info/RECORD,,