litellm-enterprise 0.1.28__tar.gz → 0.1.30__tar.gz

{litellm_enterprise-0.1.28 → litellm_enterprise-0.1.30}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: litellm-enterprise
-Version: 0.1.28
+Version: 0.1.30
 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
@@ -9,6 +10,8 @@ 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.28 → litellm_enterprise-0.1.30}/litellm_enterprise/enterprise_callbacks/send_emails/base_email.py

@@ -30,8 +30,15 @@ from litellm.integrations.email_templates.user_invitation_email import (
 from litellm.integrations.email_templates.templates import (
     MAX_BUDGET_ALERT_EMAIL_TEMPLATE,
     SOFT_BUDGET_ALERT_EMAIL_TEMPLATE,
+    TEAM_SOFT_BUDGET_ALERT_EMAIL_TEMPLATE,
+)
+from litellm.proxy._types import (
+    CallInfo,
+    InvitationNew,
+    Litellm_EntityType,
+    UserAPIKeyAuth,
+    WebhookEvent,
 )
-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 (
@@ -217,6 +224,68 @@ class BaseEmailLogger(CustomLogger):
         )
         pass
 
+    async def send_team_soft_budget_alert_email(self, event: WebhookEvent):
+        """
+        Send email to team members when team soft budget is crossed
+        Supports multiple recipients via alert_emails field from team metadata
+        """
+        # Collect all recipient emails
+        recipient_emails: List[str] = []
+        
+        # Add additional alert emails from team metadata.soft_budget_alert_emails
+        if hasattr(event, "alert_emails") and event.alert_emails:
+            for email in event.alert_emails:
+                if email and email not in recipient_emails:  # Avoid duplicates
+                    recipient_emails.append(email)
+        
+        # If no recipients found, skip sending
+        if not recipient_emails:
+            verbose_proxy_logger.warning(
+                f"No recipient emails found for team soft budget alert. event={event.model_dump(exclude_none=True)}"
+            )
+            return
+
+        verbose_proxy_logger.debug(
+            f"send_team_soft_budget_alert_email_event: {json.dumps(event.model_dump(exclude_none=True), indent=4, default=str)}"
+        )
+
+        # Get email params using the first recipient email (for template formatting)
+        email_params = await self._get_email_params(
+            email_event=EmailEvent.soft_budget_crossed,
+            user_id=event.user_id,
+            user_email=recipient_emails[0],
+            event_message=event.event_message,
+        )
+
+        # 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 />"
+
+        # Use team alias or generic greeting
+        team_alias = event.team_alias or "Team"
+
+        email_html_content = TEAM_SOFT_BUDGET_ALERT_EMAIL_TEMPLATE.format(
+            email_logo_url=email_params.logo_url,
+            team_alias=team_alias,
+            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,
+        )
+        
+        # Send email to all recipients
+        await self.send_email(
+            from_email=self.DEFAULT_LITELLM_EMAIL,
+            to_email=recipient_emails,
+            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
@@ -285,15 +354,29 @@ class BaseEmailLogger(CustomLogger):
         # - 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":
+            # For team soft budget alerts, we only need team soft_budget to be set
+            # For other entity types, we need either max_budget or soft_budget
+            if user_info.event_group == Litellm_EntityType.TEAM:
+                if user_info.soft_budget is None:
+                    return
+            else:
+                # For non-team alerts, require either max_budget or soft_budget
+                if user_info.max_budget is None and user_info.soft_budget is None:
+                    return
             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"
+                # Use appropriate ID based on event_group to ensure unique cache keys per entity type
+                if user_info.event_group == Litellm_EntityType.TEAM:
+                    _id = user_info.team_id or "default_id"
+                elif user_info.event_group == Litellm_EntityType.ORGANIZATION:
+                    _id = user_info.organization_id or "default_id"
+                elif user_info.event_group == Litellm_EntityType.USER:
+                    _id = user_info.user_id or "default_id"
+                else:
+                    # For KEY and other types, use token or user_id
+                    _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
@@ -318,10 +401,15 @@ class BaseEmailLogger(CustomLogger):
                         projected_exceeded_date=user_info.projected_exceeded_date,
                         projected_spend=user_info.projected_spend,
                         event_group=user_info.event_group,
+                        alert_emails=user_info.alert_emails,
                     )
                     
                     try:
-                        await self.send_soft_budget_alert_email(webhook_event)
+                        # Use team-specific function for team alerts, otherwise use standard function
+                        if user_info.event_group == Litellm_EntityType.TEAM:
+                            await self.send_team_soft_budget_alert_email(webhook_event)
+                        else:
+                            await self.send_soft_budget_alert_email(webhook_event)
                         
                         # Cache the alert to prevent duplicate sends
                         await _cache.async_set_cache(

{litellm_enterprise-0.1.28 → litellm_enterprise-0.1.30}/litellm_enterprise/proxy/auth/route_checks.py

@@ -36,7 +36,7 @@ class EnterpriseRouteChecks:
             if not premium_user:
                 raise HTTPException(
                     status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    detail=f"🚨🚨🚨 DISABLING LLM API ENDPOINTS is an Enterprise feature\n🚨 {CommonProxyErrors.not_premium_user.value}",
+                    detail=f"🚨🚨🚨 DISABLING ADMIN ENDPOINTS is an Enterprise feature\n🚨 {CommonProxyErrors.not_premium_user.value}",
                 )
 
         return get_secret_bool("DISABLE_ADMIN_ENDPOINTS") is True

{litellm_enterprise-0.1.28 → litellm_enterprise-0.1.30}/litellm_enterprise/proxy/common_utils/check_batch_cost.py

@@ -53,7 +53,7 @@ class CheckBatchCost:
 
         jobs = await self.prisma_client.db.litellm_managedobjecttable.find_many(
             where={
-                "status": "validating",
+                "status": {"in": ["validating", "in_progress", "finalizing"]},
                 "file_purpose": "batch",
             }
         )

{litellm_enterprise-0.1.28 → litellm_enterprise-0.1.30}/litellm_enterprise/proxy/hooks/managed_files.py

@@ -166,7 +166,11 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
                     "updated_by": user_api_key_dict.user_id,
                     "status": file_object.status,
                 },
-                "update": {},  # don't do anything if it already exists
+                "update": {
+                    "file_object": file_object.model_dump_json(),
+                    "status": file_object.status,
+                    "updated_by": user_api_key_dict.user_id,
+                },  # FIX: Update status and file_object on every operation to keep state in sync
             },
         )
 
@@ -244,6 +248,78 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
             return managed_object.created_by == user_id
         return True  # don't raise error if managed object is not found
 
+    async def list_user_batches(
+        self,
+        user_api_key_dict: UserAPIKeyAuth,
+        limit: Optional[int] = None,
+        after: Optional[str] = None,
+        provider: Optional[str] = None,
+        target_model_names: Optional[str] = None,
+        llm_router: Optional[Router] = None,
+    ) -> Dict[str, Any]:
+        # Provider filtering is not supported for managed batches
+        # This is because the encoded object ids stored in the managed objects table do not contain the provider information
+        # To support provider filtering, we would need to store the provider information in the encoded object ids
+        if provider:
+            raise Exception(
+                "Filtering by 'provider' is not supported when using managed batches."
+            )
+
+        # Model name filtering is not supported for managed batches
+        # This is because the encoded object ids stored in the managed objects table do not contain the model name
+        # A hash of the model name + litellm_params for the model name is encoded as the model id. This is not sufficient to reliably map the target model names to the model ids.
+        if target_model_names:
+            raise Exception(
+                "Filtering by 'target_model_names' is not supported when using managed batches."
+            )
+        
+        where_clause: Dict[str, Any] = {"file_purpose": "batch"}
+        
+        # Filter by user who created the batch
+        if user_api_key_dict.user_id:
+            where_clause["created_by"] = user_api_key_dict.user_id
+        
+        if after:
+            where_clause["id"] = {"gt": after}
+        
+        # Fetch more than needed to allow for post-fetch filtering
+        fetch_limit = limit or 20
+        if target_model_names:
+            # Fetch extra to account for filtering
+            fetch_limit = max(fetch_limit * 3, 100)
+        
+        batches = await self.prisma_client.db.litellm_managedobjecttable.find_many(
+            where=where_clause,
+            take=fetch_limit,
+            order={"created_at": "desc"},
+        )
+                
+        batch_objects: List[LiteLLMBatch] = []
+        for batch in batches:
+            try:
+                # Stop once we have enough after filtering
+                if len(batch_objects) >= (limit or 20):
+                    break
+
+                batch_data = json.loads(batch.file_object) if isinstance(batch.file_object, str) else batch.file_object
+                batch_obj = LiteLLMBatch(**batch_data)
+                batch_obj.id = batch.unified_object_id
+                batch_objects.append(batch_obj)
+
+            except Exception as e:
+                verbose_logger.warning(
+                    f"Failed to parse batch object {batch.unified_object_id}: {e}"
+                )
+                continue
+        
+        return {
+            "object": "list",
+            "data": batch_objects,
+            "first_id": batch_objects[0].id if batch_objects else None,
+            "last_id": batch_objects[-1].id if batch_objects else None,
+            "has_more": len(batch_objects) == (limit or 20),
+        }
+
     async def get_user_created_file_ids(
         self, user_api_key_dict: UserAPIKeyAuth, model_object_ids: List[str]
     ) -> List[OpenAIFileObject]:
@@ -282,6 +358,31 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
                 )
         return False
 
+    async def check_file_ids_access(
+        self, file_ids: List[str], user_api_key_dict: UserAPIKeyAuth
+    ) -> None:
+        """
+        Check if the user has access to a list of file IDs.
+        Only checks managed (unified) file IDs.
+        
+        Args:
+            file_ids: List of file IDs to check access for
+            user_api_key_dict: User API key authentication details
+            
+        Raises:
+            HTTPException: If user doesn't have access to any of the files
+        """
+        for file_id in file_ids:
+            is_unified_file_id = _is_base64_encoded_unified_file_id(file_id)
+            if is_unified_file_id:
+                if not await self.can_user_call_unified_file_id(
+                    file_id, user_api_key_dict
+                ):
+                    raise HTTPException(
+                        status_code=403,
+                        detail=f"User {user_api_key_dict.user_id} does not have access to the file {file_id}",
+                    )
+
     async def async_pre_call_hook(  # noqa: PLR0915
         self,
         user_api_key_dict: UserAPIKeyAuth,
@@ -297,6 +398,8 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
         if (
             call_type == CallTypes.afile_content.value
             or call_type == CallTypes.afile_delete.value
+            or call_type == CallTypes.afile_retrieve.value
+            or call_type == CallTypes.afile_content.value
         ):
             await self.check_managed_file_id_access(data, user_api_key_dict)
 
@@ -313,6 +416,9 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
             if messages:
                 file_ids = self.get_file_ids_from_messages(messages)
                 if file_ids:
+                    # Check user has access to all managed files
+                    await self.check_file_ids_access(file_ids, user_api_key_dict)
+                    
                     # 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())
@@ -328,15 +434,27 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
                     )
                     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
+            # Handle managed files in responses API input and tools
+            file_ids = []
+            
+            # Extract file IDs from input parameter
             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
+                file_ids.extend(self.get_file_ids_from_responses_input(input_data))
+            
+            # Extract file IDs from tools parameter (e.g., code_interpreter container)
+            tools = data.get("tools")
+            if tools:
+                file_ids.extend(self.get_file_ids_from_responses_tools(tools))
+            
+            if file_ids:
+                # Check user has access to all managed files
+                await self.check_file_ids_access(file_ids, user_api_key_dict)
+                
+                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"))
             potential_file_id = (
@@ -361,12 +479,16 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
                 data["model_file_id_mapping"] = model_file_id_mapping
         elif (
             call_type == CallTypes.aretrieve_batch.value
+            or call_type == CallTypes.acancel_batch.value
             or call_type == CallTypes.acancel_fine_tuning_job.value
             or call_type == CallTypes.aretrieve_fine_tuning_job.value
         ):
             accessor_key: Optional[str] = None
             retrieve_object_id: Optional[str] = None
-            if call_type == CallTypes.aretrieve_batch.value:
+            if (
+                call_type == CallTypes.aretrieve_batch.value
+                or call_type == CallTypes.acancel_batch.value
+            ):
                 accessor_key = "batch_id"
             elif (
                 call_type == CallTypes.acancel_fine_tuning_job.value
@@ -534,6 +656,41 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
         
         return file_ids
 
+    def get_file_ids_from_responses_tools(
+        self, tools: List[Dict[str, Any]]
+    ) -> List[str]:
+        """
+        Gets file ids from responses API tools parameter.
+        
+        The tools can contain code_interpreter with container.file_ids:
+        [
+            {
+                "type": "code_interpreter",
+                "container": {"type": "auto", "file_ids": ["file-123", "file-456"]}
+            }
+        ]
+        """
+        file_ids: List[str] = []
+        
+        if not isinstance(tools, list):
+            return file_ids
+        
+        for tool in tools:
+            if not isinstance(tool, dict):
+                continue
+            
+            # Check for code_interpreter with container file_ids
+            if tool.get("type") == "code_interpreter":
+                container = tool.get("container")
+                if isinstance(container, dict):
+                    container_file_ids = container.get("file_ids")
+                    if isinstance(container_file_ids, list):
+                        for file_id in container_file_ids:
+                            if isinstance(file_id, str):
+                                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:
@@ -673,6 +830,7 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
             bytes=file_objects[0].bytes,
             filename=file_objects[0].filename,
             status="uploaded",
+            expires_at=file_objects[0].expires_at,
         )
 
         return response
@@ -893,8 +1051,10 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
         delete_response = None
         specific_model_file_id_mapping = model_file_id_mapping.get(file_id)
         if specific_model_file_id_mapping:
+            # Remove conflicting keys from data to avoid duplicate keyword arguments
+            filtered_data = {k: v for k, v in data.items() if k not in ("model", "file_id")}
             for model_id, model_file_id in specific_model_file_id_mapping.items():
-                delete_response = 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, **filtered_data)  # type: ignore
 
         stored_file_object = await self.delete_unified_file_id(
             file_id, litellm_parent_otel_span

{litellm_enterprise-0.1.28 → litellm_enterprise-0.1.30}/litellm_enterprise/proxy/vector_stores/endpoints.py

@@ -282,6 +282,8 @@ async def get_vector_store_info(
                     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,
+                    team_id=vector_store.get("team_id"),
+                    user_id=vector_store.get("user_id"),
                 )
                 return {"vector_store": vector_store_pydantic_obj}
 

{litellm_enterprise-0.1.28 → litellm_enterprise-0.1.30}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "litellm-enterprise"
-version = "0.1.28"
+version = "0.1.30"
 description = "Package for LiteLLM Enterprise features"
 authors = ["BerriAI"]
 readme = "README.md"
@@ -22,7 +22,7 @@ requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.commitizen]
-version = "0.1.28"
+version = "0.1.30"
 version_files = [
     "pyproject.toml:version",
     "../requirements.txt:litellm-enterprise==",