litellm-enterprise 0.1.26__py3-none-any.whl → 0.1.28__py3-none-any.whl

litellm_enterprise/enterprise_callbacks/send_emails/base_email.py

@@ -28,11 +28,16 @@ from litellm.integrations.email_templates.user_invitation_email import (
     USER_INVITATION_EMAIL_TEMPLATE,
 )
 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):
@@ -43,7 +48,6 @@ class BaseEmailLogger(CustomLogger):
         EmailEvent.virtual_key_created: "LiteLLM: {event_message}",
         EmailEvent.virtual_key_rotated: "LiteLLM: {event_message}",
     }
-    DEFAULT_BUDGET_ALERT_TTL = 24 * 60 * 60  # 24 hours in seconds
 
     def __init__(
         self,
@@ -213,11 +217,53 @@ class BaseEmailLogger(CustomLogger):
         )
         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",
@@ -281,7 +327,7 @@ class BaseEmailLogger(CustomLogger):
                         await _cache.async_set_cache(
                             key=_cache_key,
                             value="SENT",
-                            ttl=self.DEFAULT_BUDGET_ALERT_TTL,
+                            ttl=EMAIL_BUDGET_ALERT_TTL,
                         )
                     except Exception as e:
                         verbose_proxy_logger.error(
@@ -290,6 +336,60 @@ class BaseEmailLogger(CustomLogger):
                         )
             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/proxy/__init__.py

@@ -0,0 +1 @@
+# Package marker for enterprise proxy components.

litellm_enterprise/proxy/common_utils/__init__.py

@@ -0,0 +1 @@
+# Package marker for enterprise proxy common utilities.

litellm_enterprise/proxy/common_utils/check_responses_cost.py

@@ -0,0 +1,110 @@
+"""
+Polls LiteLLM_ManagedObjectTable to check if the response is complete.
+Cost tracking is handled automatically by litellm.aget_responses().
+"""
+
+from typing import TYPE_CHECKING
+
+import litellm
+from litellm._logging import verbose_proxy_logger
+
+if TYPE_CHECKING:
+    from litellm.proxy.utils import PrismaClient, ProxyLogging
+    from litellm.router import Router
+
+
+class CheckResponsesCost:
+    def __init__(
+        self,
+        proxy_logging_obj: "ProxyLogging",
+        prisma_client: "PrismaClient",
+        llm_router: "Router",
+    ):
+        from litellm.proxy.utils import PrismaClient, ProxyLogging
+        from litellm.router import Router
+
+        self.proxy_logging_obj: ProxyLogging = proxy_logging_obj
+        self.prisma_client: PrismaClient = prisma_client
+        self.llm_router: Router = llm_router
+
+    async def check_responses_cost(self):
+        """
+        Check if background responses are complete and track their cost.
+        - Get all status="queued" or "in_progress" and file_purpose="response" jobs
+        - Query the provider to check if response is complete
+        - Cost is automatically tracked by litellm.aget_responses()
+        - Mark completed/failed/cancelled responses as complete in the database
+        """
+        jobs = await self.prisma_client.db.litellm_managedobjecttable.find_many(
+            where={
+                "status": {"in": ["queued", "in_progress"]},
+                "file_purpose": "response",
+            }
+        )
+        
+        verbose_proxy_logger.debug(f"Found {len(jobs)} response jobs to check")
+        completed_jobs = []
+
+        for job in jobs:
+            unified_object_id = job.unified_object_id
+
+            try:
+                from litellm.proxy.hooks.responses_id_security import (
+                    ResponsesIDSecurity,
+                )
+
+                # Get the stored response object to extract model information
+                stored_response = job.file_object
+                model_name = stored_response.get("model", None)
+                
+                # Decrypt the response ID
+                responses_id_security, _, _ = ResponsesIDSecurity()._decrypt_response_id(unified_object_id)
+                
+                # Prepare metadata with model information for cost tracking
+                litellm_metadata = {
+                    "user_api_key_user_id": job.created_by or "default-user-id",
+                }
+                
+                # Add model information if available
+                if model_name:
+                    litellm_metadata["model"] = model_name
+                    litellm_metadata["model_group"] = model_name  # Use same value for model_group
+                
+                response = await litellm.aget_responses(
+                    response_id=responses_id_security,
+                    litellm_metadata=litellm_metadata,
+                )
+                
+                verbose_proxy_logger.debug(
+                    f"Response {unified_object_id} status: {response.status}, model: {model_name}"
+                )
+                
+            except Exception as e:
+                verbose_proxy_logger.info(
+                    f"Skipping job {unified_object_id} due to error: {e}"
+                )
+                continue
+
+            # Check if response is in a terminal state
+            if response.status == "completed":
+                verbose_proxy_logger.info(
+                    f"Response {unified_object_id} is complete. Cost automatically tracked by aget_responses."
+                )
+                completed_jobs.append(job)
+                
+            elif response.status in ["failed", "cancelled"]:
+                verbose_proxy_logger.info(
+                    f"Response {unified_object_id} has status {response.status}, marking as complete"
+                )
+                completed_jobs.append(job)
+
+        # Mark completed jobs in the database
+        if len(completed_jobs) > 0:
+            await self.prisma_client.db.litellm_managedobjecttable.update_many(
+                where={"id": {"in": [job.id for job in completed_jobs]}},
+                data={"status": "completed"},
+            )
+            verbose_proxy_logger.info(
+                f"Marked {len(completed_jobs)} response jobs as completed"
+            )
+

litellm_enterprise/proxy/hooks/managed_files.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Union, cas
 
 from fastapi import HTTPException
 
+import litellm
 from litellm import Router, verbose_logger
 from litellm._uuid import uuid
 from litellm.caching.caching import DualCache
@@ -23,7 +24,9 @@ from litellm.proxy._types import (
 from litellm.proxy.openai_files_endpoints.common_utils import (
     _is_base64_encoded_unified_file_id,
     get_batch_id_from_unified_batch_id,
+    get_content_type_from_file_object,
     get_model_id_from_unified_batch_id,
+    normalize_mime_type_for_provider,
 )
 from litellm.types.llms.openai import (
     AllMessageValues,
@@ -33,6 +36,7 @@ from litellm.types.llms.openai import (
     FileObject,
     OpenAIFileObject,
     OpenAIFilesPurpose,
+    ResponsesAPIResponse,
 )
 from litellm.types.utils import (
     CallTypesLiteral,
@@ -41,10 +45,6 @@ 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
@@ -133,10 +133,10 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
     async def store_unified_object_id(
         self,
         unified_object_id: str,
-        file_object: Union[LiteLLMBatch, LiteLLMFineTuningJob],
+        file_object: Union[LiteLLMBatch, LiteLLMFineTuningJob, "ResponsesAPIResponse"],
         litellm_parent_otel_span: Optional[Span],
         model_object_id: str,
-        file_purpose: Literal["batch", "fine-tune"],
+        file_purpose: Literal["batch", "fine-tune", "response"],
         user_api_key_dict: UserAPIKeyAuth,
     ) -> None:
         verbose_logger.info(
@@ -750,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,
@@ -819,15 +837,36 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
         return response
 
     async def afile_retrieve(
-        self, file_id: str, litellm_parent_otel_span: Optional[Span]
+        self, file_id: str, litellm_parent_otel_span: Optional[Span], llm_router=None
     ) -> OpenAIFileObject:
         stored_file_object = await self.get_unified_file_id(
             file_id, litellm_parent_otel_span
         )
-        if stored_file_object:
-            return stored_file_object.file_object
-        else:
+
+        # Case 1 : This is not a managed file
+        if not stored_file_object:
             raise Exception(f"LiteLLM Managed File object with id={file_id} not found")
+        
+        # Case 2: Managed file and the file object exists in the database
+        if stored_file_object and stored_file_object.file_object:
+            return stored_file_object.file_object
+
+        # Case 3: Managed file exists in the database but not the file object (for. e.g the batch task might not have run)
+        # So we fetch the file object from the provider. We deliberately do not store the result to avoid interfering with batch cost tracking code.
+        if not llm_router:
+            raise Exception(
+                f"LiteLLM Managed File object with id={file_id} has no file_object "
+                f"and llm_router is required to fetch from provider"
+            )
+
+        try:
+            model_id, model_file_id = next(iter(stored_file_object.model_mappings.items()))
+            credentials = llm_router.get_deployment_credentials_with_provider(model_id) or {}
+            response = await litellm.afile_retrieve(file_id=model_file_id, **credentials)
+            response.id = file_id  # Replace with unified ID
+            return response
+        except Exception as e:
+            raise Exception(f"Failed to retrieve file {file_id} from provider: {str(e)}") from e
 
     async def afile_list(
         self,
@@ -851,10 +890,11 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
             [file_id], litellm_parent_otel_span
         )
 
+        delete_response = None
         specific_model_file_id_mapping = model_file_id_mapping.get(file_id)
         if specific_model_file_id_mapping:
             for model_id, model_file_id in specific_model_file_id_mapping.items():
-                await llm_router.afile_delete(model=model_id, file_id=model_file_id, **data)  # type: ignore
+                delete_response = await llm_router.afile_delete(model=model_id, file_id=model_file_id, **data)  # type: ignore
 
         stored_file_object = await self.delete_unified_file_id(
             file_id, litellm_parent_otel_span
@@ -862,6 +902,9 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
 
         if stored_file_object:
             return stored_file_object
+        elif delete_response:
+            delete_response.id = file_id
+            return delete_response
         else:
             raise Exception(f"LiteLLM Managed File object with id={file_id} not found")
 
@@ -928,7 +971,9 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
             
             # 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
+                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

litellm_enterprise/types/enterprise_callbacks/send_emails.py

@@ -37,6 +37,7 @@ class EmailEvent(str, enum.Enum):
     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
@@ -53,6 +54,7 @@ class DefaultEmailSettings(BaseModel):
             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.26.dist-info → litellm_enterprise-0.1.28.dist-info}/METADATA

@@ -1,8 +1,7 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: litellm-enterprise
-Version: 0.1.26
+Version: 0.1.28
 Summary: Package for LiteLLM Enterprise features
-License-File: LICENSE.md
 Author: BerriAI
 Requires-Python: >=3.8, !=2.7.*, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*
 Classifier: Programming Language :: Python :: 3
@@ -10,8 +9,6 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
 Project-URL: Documentation, https://docs.litellm.ai
 Project-URL: Homepage, https://litellm.ai
 Project-URL: Repository, https://github.com/BerriAI/litellm

{litellm_enterprise-0.1.26.dist-info → litellm_enterprise-0.1.28.dist-info}/RECORD

@@ -99,21 +99,24 @@ 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=hUdNvzjE5MM05BWlkFnaM232B8jwABWskNntd4mPmSo,21174
+litellm_enterprise/enterprise_callbacks/send_emails/base_email.py,sha256=O_xNeGIQckN0wEhyC3jf-LyNKiI2YaQnqLMUxAljUiU,26121
 litellm_enterprise/enterprise_callbacks/send_emails/endpoints.py,sha256=hOEpM_q8MJAXlKMOtC9KbgvDVr_YFtF3reu9bjXkpsI,7017
 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/__init__.py,sha256=mnCBJ6Y98ai1RfVpYpCxavTPSTmdZ0e-kxX1qtaGIeo,50
 litellm_enterprise/proxy/audit_logging_endpoints.py,sha256=BnHczmi4bnW1GpMNsq4CvnbwL3rgQ-pnrtFd5WBbbHY,5304
 litellm_enterprise/proxy/auth/__init__.py,sha256=wTXtbDcLrD_qecxJfEJtraeCvGfldDgLz8qdVggLoSI,301
 litellm_enterprise/proxy/auth/custom_sso_handler.py,sha256=ITML9dRKL-LuJhU3WKKVPDp0ECfYxvxTvuX8GpSM0gE,3439
 litellm_enterprise/proxy/auth/route_checks.py,sha256=FbXwbrOkFr1dODH6XxoIpLG1nKowC7kyNaRR0WR6ujU,2490
 litellm_enterprise/proxy/auth/user_api_key_auth.py,sha256=7t5Q-JoKFyoymylaOT8KWAAOFVz0JOTl7PPOmTkpj5c,1144
+litellm_enterprise/proxy/common_utils/__init__.py,sha256=zmdmvktxSsUOpGp1TxwJeV8zyLPt4938NXtato4YqLI,56
 litellm_enterprise/proxy/common_utils/check_batch_cost.py,sha256=V0CCHtN-JV-_d-ydXV-cVs3zCImt1699JnICGF3oPOk,7360
+litellm_enterprise/proxy/common_utils/check_responses_cost.py,sha256=EKZ78mzpYjxmOtSXeoxfXRZX88MJtaoMyx6NQEPC8AU,4301
 litellm_enterprise/proxy/enterprise_routes.py,sha256=ToJVSSNaYUotzgIg-kWsfsqh2E0GnQirOPkpE4YkHNg,907
-litellm_enterprise/proxy/hooks/managed_files.py,sha256=_LxdyyhHJa_uZDbkwpdUCbDSCbM6qK-4z8_BHoj189o,41480
+litellm_enterprise/proxy/hooks/managed_files.py,sha256=Bbcd4mipfELbNz9VULv_DJBoKutfryEBZvCG1fC4Uf8,43898
 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 +124,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=to7W50SCGKh14FB3gsnlzY_snyxa8M8LAAi_zXbJsb8,2044
+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.26.dist-info/METADATA,sha256=CUF0ZS8-TuSbpGp3-q4g3VV30wvf4HaSIIaz0A6Gz-Q,1441
-litellm_enterprise-0.1.26.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-litellm_enterprise-0.1.26.dist-info/licenses/LICENSE.md,sha256=nq3D9ZqOvRDT6hLkypQFTc3XsE15kbkg5rkkLJVSqKY,2251
-litellm_enterprise-0.1.26.dist-info/RECORD,,
+litellm_enterprise-0.1.28.dist-info/LICENSE.md,sha256=nq3D9ZqOvRDT6hLkypQFTc3XsE15kbkg5rkkLJVSqKY,2251
+litellm_enterprise-0.1.28.dist-info/METADATA,sha256=d9TUgJdtXBhVu8JQsTyTk0W9lyVuQPLI2ajs_I8Pmqk,1314
+litellm_enterprise-0.1.28.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+litellm_enterprise-0.1.28.dist-info/RECORD,,

{litellm_enterprise-0.1.26.dist-info → litellm_enterprise-0.1.28.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any