litellm-enterprise 0.1.20__py3-none-any.whl → 0.1.22__py3-none-any.whl

litellm_enterprise/enterprise_callbacks/callback_controls.py

@@ -40,7 +40,7 @@ class EnterpriseCallbackControls:
                     #########################################################
                     # premium user check
                     #########################################################
-                    if not EnterpriseCallbackControls._premium_user_check():
+                    if not EnterpriseCallbackControls._should_allow_dynamic_callback_disabling():
                         return False
                     #########################################################
                     if isinstance(callback, str):
@@ -84,8 +84,15 @@ class EnterpriseCallbackControls:
         return None
     
     @staticmethod
-    def _premium_user_check():
+    def _should_allow_dynamic_callback_disabling():
+        import litellm
         from litellm.proxy.proxy_server import premium_user
+
+        # Check if admin has disabled this feature
+        if litellm.allow_dynamic_callback_disabling is not True:
+            verbose_logger.debug("Dynamic callback disabling is disabled by admin via litellm.allow_dynamic_callback_disabling")
+            return False
+        
         if premium_user:
             return True
         verbose_logger.warning(f"Disabling callbacks using request headers is an enterprise feature. {CommonProxyErrors.not_premium_user.value}")

litellm_enterprise/enterprise_callbacks/generic_api_callback.py

@@ -9,7 +9,7 @@ Callback to log events to a Generic API Endpoint
 import asyncio
 import os
 import traceback
-import uuid
+from litellm._uuid import uuid
 from typing import Dict, List, Optional, Union
 
 import litellm

litellm_enterprise/enterprise_callbacks/llama_guard.py

@@ -23,7 +23,7 @@ import litellm
 from litellm._logging import verbose_proxy_logger
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.proxy._types import UserAPIKeyAuth
-from litellm.types.utils import Choices, ModelResponse
+from litellm.types.utils import CallTypesLiteral, Choices, ModelResponse
 
 
 class _ENTERPRISE_LlamaGuard(CustomLogger):
@@ -98,15 +98,7 @@ class _ENTERPRISE_LlamaGuard(CustomLogger):
         self,
         data: dict,
         user_api_key_dict: UserAPIKeyAuth,
-        call_type: Literal[
-            "completion",
-            "embeddings",
-            "image_generation",
-            "moderation",
-            "audio_transcription",
-            "responses",
-            "mcp_call",
-        ],
+        call_type: CallTypesLiteral,
     ):
         """
         - Calls the Llama Guard Endpoint

litellm_enterprise/enterprise_callbacks/llm_guard.py

@@ -17,6 +17,7 @@ from litellm._logging import verbose_proxy_logger
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.proxy._types import UserAPIKeyAuth
 from litellm.secret_managers.main import get_secret_str
+from litellm.types.utils import CallTypesLiteral
 from litellm.utils import get_formatted_prompt
 
 
@@ -120,15 +121,7 @@ class _ENTERPRISE_LLMGuard(CustomLogger):
         self,
         data: dict,
         user_api_key_dict: UserAPIKeyAuth,
-        call_type: Literal[
-            "completion",
-            "embeddings",
-            "image_generation",
-            "moderation",
-            "audio_transcription",
-            "responses",
-            "mcp_call",
-        ],
+        call_type: CallTypesLiteral,
     ):
         """
         - Calls the LLM Guard Endpoint

litellm_enterprise/enterprise_callbacks/pagerduty/pagerduty.py

@@ -31,6 +31,7 @@ from litellm.types.integrations.pagerduty import (
     PagerDutyRequestBody,
 )
 from litellm.types.utils import (
+    CallTypesLiteral,
     StandardLoggingPayload,
     StandardLoggingPayloadErrorInformation,
 )
@@ -119,6 +120,7 @@ class PagerDutyAlerting(SlackAlerting):
                 user_api_key_end_user_id=_meta.get("user_api_key_end_user_id"),
                 user_api_key_user_email=_meta.get("user_api_key_user_email"),
                 user_api_key_request_route=_meta.get("user_api_key_request_route"),
+                user_api_key_auth_metadata=_meta.get("user_api_key_auth_metadata"),
             )
         )
 
@@ -141,17 +143,7 @@ class PagerDutyAlerting(SlackAlerting):
         user_api_key_dict: UserAPIKeyAuth,
         cache: DualCache,
         data: dict,
-        call_type: Literal[
-            "completion",
-            "text_completion",
-            "embeddings",
-            "image_generation",
-            "moderation",
-            "audio_transcription",
-            "pass_through_endpoint",
-            "rerank",
-            "mcp_call",
-        ],
+        call_type: CallTypesLiteral,
     ) -> Optional[Union[Exception, str, dict]]:
         """
         Example of detecting hanging requests by waiting a given threshold.
@@ -196,7 +188,11 @@ class PagerDutyAlerting(SlackAlerting):
                 user_api_key_alias=user_api_key_dict.key_alias,
                 user_api_key_spend=user_api_key_dict.spend,
                 user_api_key_max_budget=user_api_key_dict.max_budget,
-                user_api_key_budget_reset_at=user_api_key_dict.budget_reset_at.isoformat() if user_api_key_dict.budget_reset_at else None,
+                user_api_key_budget_reset_at=(
+                    user_api_key_dict.budget_reset_at.isoformat()
+                    if user_api_key_dict.budget_reset_at
+                    else None
+                ),
                 user_api_key_org_id=user_api_key_dict.org_id,
                 user_api_key_team_id=user_api_key_dict.team_id,
                 user_api_key_user_id=user_api_key_dict.user_id,
@@ -204,6 +200,7 @@ class PagerDutyAlerting(SlackAlerting):
                 user_api_key_end_user_id=user_api_key_dict.end_user_id,
                 user_api_key_user_email=user_api_key_dict.user_email,
                 user_api_key_request_route=user_api_key_dict.request_route,
+                user_api_key_auth_metadata=user_api_key_dict.metadata,
             )
         )
 

litellm_enterprise/enterprise_callbacks/send_emails/base_email.py

@@ -11,6 +11,7 @@ from litellm_enterprise.types.enterprise_callbacks.send_emails import (
     EmailEvent,
     EmailParams,
     SendKeyCreatedEmailEvent,
+    SendKeyRotatedEmailEvent,
 )
 
 from litellm._logging import verbose_proxy_logger
@@ -19,10 +20,14 @@ from litellm.integrations.email_templates.email_footer import EMAIL_FOOTER
 from litellm.integrations.email_templates.key_created_email import (
     KEY_CREATED_EMAIL_TEMPLATE,
 )
+from litellm.integrations.email_templates.key_rotated_email import (
+    KEY_ROTATED_EMAIL_TEMPLATE,
+)
 from litellm.integrations.email_templates.user_invitation_email import (
     USER_INVITATION_EMAIL_TEMPLATE,
 )
 from litellm.proxy._types import InvitationNew, UserAPIKeyAuth, WebhookEvent
+from litellm.secret_managers.main import get_secret_bool
 from litellm.types.integrations.slack_alerting import LITELLM_LOGO_URL
 
 
@@ -32,6 +37,7 @@ class BaseEmailLogger(CustomLogger):
     DEFAULT_SUBJECT_TEMPLATES = {
         EmailEvent.new_user_invitation: "LiteLLM: {event_message}",
         EmailEvent.virtual_key_created: "LiteLLM: {event_message}",
+        EmailEvent.virtual_key_rotated: "LiteLLM: {event_message}",
     }
 
     async def send_user_invitation_email(self, event: WebhookEvent):
@@ -83,11 +89,58 @@ class BaseEmailLogger(CustomLogger):
             f"send_key_created_email_event: {json.dumps(send_key_created_email_event, indent=4, default=str)}"
         )
 
+        # Check if API key should be included in email
+        include_api_key = get_secret_bool(secret_name="EMAIL_INCLUDE_API_KEY", default_value=True)
+        if include_api_key is None:
+            include_api_key = True  # Default to True if not set
+        key_token_display = send_key_created_email_event.virtual_key if include_api_key else "[Key hidden for security - retrieve from dashboard]"
+
         email_html_content = KEY_CREATED_EMAIL_TEMPLATE.format(
             email_logo_url=email_params.logo_url,
             recipient_email=email_params.recipient_email,
             key_budget=self._format_key_budget(send_key_created_email_event.max_budget),
-            key_token=send_key_created_email_event.virtual_key,
+            key_token=key_token_display,
+            base_url=email_params.base_url,
+            email_support_contact=email_params.support_contact,
+            email_footer=email_params.signature,
+        )
+
+        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_key_rotated_email(
+        self, send_key_rotated_email_event: SendKeyRotatedEmailEvent
+    ):
+        """
+        Send email to user after rotating key for the user
+        """
+        email_params = await self._get_email_params(
+            user_id=send_key_rotated_email_event.user_id,
+            user_email=send_key_rotated_email_event.user_email,
+            email_event=EmailEvent.virtual_key_rotated,
+            event_message=send_key_rotated_email_event.event_message,
+        )
+
+        verbose_proxy_logger.debug(
+            f"send_key_rotated_email_event: {json.dumps(send_key_rotated_email_event, indent=4, default=str)}"
+        )
+
+        # Check if API key should be included in email
+        include_api_key = get_secret_bool(secret_name="EMAIL_INCLUDE_API_KEY", default_value=True)
+        if include_api_key is None:
+            include_api_key = True  # Default to True if not set
+        key_token_display = send_key_rotated_email_event.virtual_key if include_api_key else "[Key hidden for security - retrieve from dashboard]"
+
+        email_html_content = KEY_ROTATED_EMAIL_TEMPLATE.format(
+            email_logo_url=email_params.logo_url,
+            recipient_email=email_params.recipient_email,
+            key_budget=self._format_key_budget(send_key_rotated_email_event.max_budget),
+            key_token=key_token_display,
             base_url=email_params.base_url,
             email_support_contact=email_params.support_contact,
             email_footer=email_params.signature,
@@ -159,6 +212,13 @@ class BaseEmailLogger(CustomLogger):
                 self.DEFAULT_SUBJECT_TEMPLATES[EmailEvent.virtual_key_created],
                 "key created subject template"
             )
+        elif email_event == EmailEvent.virtual_key_rotated:
+            custom_subject_key_rotated = os.getenv("EMAIL_SUBJECT_KEY_ROTATED", None)
+            subject_template = get_custom_or_default(
+                custom_subject_key_rotated,
+                self.DEFAULT_SUBJECT_TEMPLATES[EmailEvent.virtual_key_rotated],
+                "key rotated subject template"
+            )
         else:
             subject_template = "LiteLLM: {event_message}"
 

litellm_enterprise/integrations/custom_guardrail.py

@@ -29,11 +29,10 @@ class EnterpriseCustomGuardrailHelper:
         if event_hook is None or not isinstance(event_hook, Mode):
             return None
 
-        metadata: dict = data.get("litellm_metadata") or data.get("metadata", {})
         proxy_server_request = data.get("proxy_server_request", {})
 
         request_tags = StandardLoggingPayloadSetup._get_request_tags(
-            metadata=metadata,
+            litellm_params=data,
             proxy_server_request=proxy_server_request,
         )
 

litellm_enterprise/proxy/common_utils/check_batch_cost.py

@@ -2,7 +2,7 @@
 Polls LiteLLM_ManagedObjectTable to check if the batch job is complete, and if the cost has been tracked.
 """
 
-import uuid
+from litellm._uuid import uuid
 from datetime import datetime
 from typing import TYPE_CHECKING, Optional, cast
 
@@ -57,7 +57,6 @@ class CheckBatchCost:
                 "file_purpose": "batch",
             }
         )
-
         completed_jobs = []
 
         for job in jobs:
@@ -139,7 +138,7 @@ class CheckBatchCost:
                 custom_llm_provider = deployment_info.litellm_params.custom_llm_provider
                 litellm_model_name = deployment_info.litellm_params.model
 
-                _, llm_provider, _, _ = get_llm_provider(
+                model_name, llm_provider, _, _ = get_llm_provider(
                     model=litellm_model_name,
                     custom_llm_provider=custom_llm_provider,
                 )
@@ -148,9 +147,9 @@ class CheckBatchCost:
                     await calculate_batch_cost_and_usage(
                         file_content_dictionary=file_content_as_dict,
                         custom_llm_provider=llm_provider,  # type: ignore
+                        model_name=model_name,
                     )
                 )
-
                 logging_obj = LiteLLMLogging(
                     model=batch_models[0],
                     messages=[{"role": "user", "content": "<retrieve_batch>"}],

litellm_enterprise/proxy/hooks/managed_files.py

@@ -4,12 +4,12 @@
 import asyncio
 import base64
 import json
-import uuid
 from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Union, cast
 
 from fastapi import HTTPException
 
 from litellm import Router, verbose_logger
+from litellm._uuid import uuid
 from litellm.caching.caching import DualCache
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.litellm_core_utils.prompt_templates.common_utils import extract_file_data
@@ -36,6 +36,7 @@ from litellm.types.llms.openai import (
     OpenAIFilesPurpose,
 )
 from litellm.types.utils import (
+    CallTypesLiteral,
     LiteLLMBatch,
     LiteLLMFineTuningJob,
     LLMResponseTypes,
@@ -152,7 +153,7 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
                     "status": file_object.status,
                 },
                 "update": {},  # don't do anything if it already exists
-            }
+            },
         )
 
     async def get_unified_file_id(
@@ -224,9 +225,10 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
                 where={"unified_object_id": unified_object_id}
             )
         )
+
         if managed_object:
             return managed_object.created_by == user_id
-        return False
+        return True  # don't raise error if managed object is not found
 
     async def get_user_created_file_ids(
         self, user_api_key_dict: UserAPIKeyAuth, model_object_ids: List[str]
@@ -271,27 +273,7 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
         user_api_key_dict: UserAPIKeyAuth,
         cache: DualCache,
         data: Dict,
-        call_type: Literal[
-            "completion",
-            "text_completion",
-            "embeddings",
-            "image_generation",
-            "moderation",
-            "audio_transcription",
-            "pass_through_endpoint",
-            "rerank",
-            "acreate_batch",
-            "aretrieve_batch",
-            "acreate_file",
-            "afile_list",
-            "afile_delete",
-            "afile_content",
-            "acreate_fine_tuning_job",
-            "aretrieve_fine_tuning_job",
-            "alist_fine_tuning_jobs",
-            "acancel_fine_tuning_job",
-            "mcp_call",
-        ],
+        call_type: CallTypesLiteral,
     ) -> Union[Exception, str, Dict, None]:
         """
         - Detect litellm_proxy/ file_id
@@ -314,6 +296,16 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
                         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
+            input_data = data.get("input")
+            if input_data:
+                file_ids = self.get_file_ids_from_responses_input(input_data)
+                if file_ids:
+                    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.afile_content.value:
             retrieve_file_id = cast(Optional[str], data.get("file_id"))
@@ -471,6 +463,47 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
                                 file_ids.append(file_id)
         return file_ids
 
+    def get_file_ids_from_responses_input(
+        self, input: Union[str, List[Dict[str, Any]]]
+    ) -> List[str]:
+        """
+        Gets file ids from responses API input.
+        
+        The input can be:
+        - A string (no files)
+        - A list of input items, where each item can have:
+          - type: "input_file" with file_id
+          - content: a list that can contain items with type: "input_file" and file_id
+        """
+        file_ids: List[str] = []
+        
+        if isinstance(input, str):
+            return file_ids
+        
+        if not isinstance(input, list):
+            return file_ids
+        
+        for item in input:
+            if not isinstance(item, dict):
+                continue
+            
+            # Check for direct input_file type
+            if item.get("type") == "input_file":
+                file_id = item.get("file_id")
+                if file_id:
+                    file_ids.append(file_id)
+            
+            # Check for input_file in content array
+            content = item.get("content")
+            if isinstance(content, list):
+                for content_item in content:
+                    if isinstance(content_item, dict) and content_item.get("type") == "input_file":
+                        file_id = content_item.get("file_id")
+                        if file_id:
+                            file_ids.append(file_id)
+        
+        return file_ids
+
     async def get_model_file_id_mapping(
         self, file_ids: List[str], litellm_parent_otel_span: Span
     ) -> dict:
@@ -496,7 +529,6 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
         for file_id in file_ids:
             ## CHECK IF FILE ID IS MANAGED BY LITELM
             is_base64_unified_file_id = _is_base64_encoded_unified_file_id(file_id)
-
             if is_base64_unified_file_id:
                 litellm_managed_file_ids.append(file_id)
 
@@ -507,6 +539,7 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
                 unified_file_object = await self.get_unified_file_id(
                     file_id, litellm_parent_otel_span
                 )
+
                 if unified_file_object:
                     file_id_mapping[file_id] = unified_file_object.model_mappings
 
@@ -782,18 +815,21 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
         llm_router: Router,
         **data: Dict,
     ) -> OpenAIFileObject:
-        file_id = convert_b64_uid_to_unified_uid(file_id)
+
+        # file_id = convert_b64_uid_to_unified_uid(file_id)
         model_file_id_mapping = await self.get_model_file_id_mapping(
             [file_id], litellm_parent_otel_span
         )
+
         specific_model_file_id_mapping = model_file_id_mapping.get(file_id)
         if specific_model_file_id_mapping:
-            for model_id, file_id in specific_model_file_id_mapping.items():
-                await llm_router.afile_delete(model=model_id, file_id=file_id, **data)  # type: ignore
+            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
 
         stored_file_object = await self.delete_unified_file_id(
             file_id, litellm_parent_otel_span
         )
+
         if stored_file_object:
             return stored_file_object
         else:
@@ -814,6 +850,7 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
             model_file_id_mapping
             or await self.get_model_file_id_mapping([file_id], litellm_parent_otel_span)
         )
+
         specific_model_file_id_mapping = model_file_id_mapping.get(file_id)
 
         if specific_model_file_id_mapping:

litellm_enterprise/proxy/management_endpoints/internal_user_endpoints.py

@@ -2,7 +2,6 @@
 Enterprise internal user management endpoints
 """
 
-import os
 
 from fastapi import APIRouter, Depends, HTTPException
 

litellm_enterprise/proxy/management_endpoints/key_management_endpoints.py

@@ -22,9 +22,21 @@ def add_team_member_key_duration(
     return data
 
 
+def add_team_organization_id(
+    team_table: Optional[LiteLLM_TeamTable],
+    data: GenerateKeyRequest,
+) -> GenerateKeyRequest:
+    if team_table is None:
+        return data
+    setattr(data, "organization_id", team_table.organization_id)
+    return data
+
+
 def apply_enterprise_key_management_params(
     data: GenerateKeyRequest,
     team_table: Optional[LiteLLM_TeamTable],
 ) -> GenerateKeyRequest:
+
     data = add_team_member_key_duration(team_table, data)
+    data = add_team_organization_id(team_table, data)
     return data

litellm_enterprise/proxy/vector_stores/endpoints.py

@@ -9,14 +9,19 @@ All /vector_store management endpoints
 """
 
 import copy
+import json
 from typing import List, Optional
 
-from fastapi import APIRouter, Depends, HTTPException, Request, Response
+from fastapi import APIRouter, Depends, HTTPException
 
 import litellm
 from litellm._logging import verbose_proxy_logger
 from litellm.litellm_core_utils.safe_json_dumps import safe_dumps
-from litellm.proxy._types import UserAPIKeyAuth
+from litellm.proxy._types import (
+    LiteLLM_ManagedVectorStoresTable,
+    ResponseLiteLLM_ManagedVectorStore,
+    UserAPIKeyAuth,
+)
 from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
 from litellm.types.vector_stores import (
     LiteLLM_ManagedVectorStore,
@@ -29,6 +34,7 @@ from litellm.vector_stores.vector_store_registry import VectorStoreRegistry
 
 router = APIRouter()
 
+
 ########################################################
 # Management Endpoints
 ########################################################
@@ -79,7 +85,9 @@ async def new_vector_store(
         litellm_params_json: Optional[str] = None
         _input_litellm_params: dict = vector_store.get("litellm_params", {}) or {}
         if _input_litellm_params is not None:
-            litellm_params_dict = GenericLiteLLMParams(**_input_litellm_params).model_dump(exclude_none=True)
+            litellm_params_dict = GenericLiteLLMParams(
+                **_input_litellm_params
+            ).model_dump(exclude_none=True)
             litellm_params_json = safe_dumps(litellm_params_dict)
             del vector_store["litellm_params"]
 
@@ -227,6 +235,7 @@ async def delete_vector_store(
     "/vector_store/info",
     tags=["vector store management"],
     dependencies=[Depends(user_api_key_auth)],
+    response_model=ResponseLiteLLM_ManagedVectorStore,
 )
 async def get_vector_store_info(
     data: VectorStoreInfoRequest,
@@ -239,8 +248,39 @@ async def get_vector_store_info(
         raise HTTPException(status_code=500, detail="Database not connected")
 
     try:
-        vector_store = await prisma_client.db.litellm_managedvectorstorestable.find_unique(
-            where={"vector_store_id": data.vector_store_id}
+        if litellm.vector_store_registry is not None:
+            vector_store = litellm.vector_store_registry.get_litellm_managed_vector_store_from_registry(
+                vector_store_id=data.vector_store_id
+            )
+            if vector_store is not None:
+                vector_store_metadata = vector_store.get("vector_store_metadata")
+                # Parse metadata if it's a JSON string
+                parsed_metadata: Optional[dict] = None
+                if isinstance(vector_store_metadata, str):
+                    parsed_metadata = json.loads(vector_store_metadata)
+                elif isinstance(vector_store_metadata, dict):
+                    parsed_metadata = vector_store_metadata
+
+                vector_store_pydantic_obj = LiteLLM_ManagedVectorStoresTable(
+                    vector_store_id=vector_store.get("vector_store_id") or "",
+                    custom_llm_provider=vector_store.get("custom_llm_provider") or "",
+                    vector_store_name=vector_store.get("vector_store_name") or None,
+                    vector_store_description=vector_store.get(
+                        "vector_store_description"
+                    )
+                    or None,
+                    vector_store_metadata=parsed_metadata,
+                    created_at=vector_store.get("created_at") or None,
+                    updated_at=vector_store.get("updated_at") or None,
+                    litellm_credential_name=vector_store.get("litellm_credential_name"),
+                    litellm_params=vector_store.get("litellm_params") or None,
+                )
+                return {"vector_store": vector_store_pydantic_obj}
+
+        vector_store = (
+            await prisma_client.db.litellm_managedvectorstorestable.find_unique(
+                where={"vector_store_id": data.vector_store_id}
+            )
         )
         if vector_store is None:
             raise HTTPException(
@@ -248,7 +288,7 @@ async def get_vector_store_info(
                 detail=f"Vector store with ID {data.vector_store_id} not found",
             )
 
-        vector_store_dict = vector_store.model_dump()
+        vector_store_dict = vector_store.model_dump()  # type: ignore[attr-defined]
         return {"vector_store": vector_store_dict}
     except Exception as e:
         verbose_proxy_logger.exception(f"Error getting vector store info: {str(e)}")
@@ -274,7 +314,9 @@ async def update_vector_store(
         update_data = data.model_dump(exclude_unset=True)
         vector_store_id = update_data.pop("vector_store_id")
         if update_data.get("vector_store_metadata") is not None:
-            update_data["vector_store_metadata"] = safe_dumps(update_data["vector_store_metadata"])
+            update_data["vector_store_metadata"] = safe_dumps(
+                update_data["vector_store_metadata"]
+            )
 
         updated = await prisma_client.db.litellm_managedvectorstorestable.update(
             where={"vector_store_id": vector_store_id},

litellm_enterprise/types/enterprise_callbacks/send_emails.py

@@ -1,10 +1,11 @@
 import enum
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from pydantic import BaseModel, Field
 
 from litellm.proxy._types import WebhookEvent
 
+
 class EmailParams(BaseModel):
     logo_url: str
     support_contact: str
@@ -22,9 +23,19 @@ class SendKeyCreatedEmailEvent(WebhookEvent):
     """
 
 
+class SendKeyRotatedEmailEvent(WebhookEvent):
+    virtual_key: str
+    key_alias: Optional[str] = None
+    """
+    The virtual key that was rotated
+    this will be sk-123xxx, since we will be emailing this to the user to start using the new key
+    """
+
+
 class EmailEvent(str, enum.Enum):
     virtual_key_created = "Virtual Key Created"
     new_user_invitation = "New User Invitation"
+    virtual_key_rotated = "Virtual Key Rotated"
 
 class EmailEventSettings(BaseModel):
     event: EmailEvent
@@ -37,8 +48,9 @@ class DefaultEmailSettings(BaseModel):
     """Default settings for email events"""
     settings: Dict[EmailEvent, bool] = Field(
         default_factory=lambda: {
-            EmailEvent.virtual_key_created: False,  # Off by default
+            EmailEvent.virtual_key_created: True,  # On by default
             EmailEvent.new_user_invitation: True,  # On by default
+            EmailEvent.virtual_key_rotated: True,  # On by default
         }
     )
     def to_dict(self) -> Dict[str, bool]: