litellm-enterprise 0.1.27__tar.gz → 0.1.29__tar.gz

{litellm_enterprise-0.1.27 → litellm_enterprise-0.1.29}/PKG-INFO

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

{litellm_enterprise-0.1.27 → litellm_enterprise-0.1.29}/litellm_enterprise/enterprise_callbacks/send_emails/base_email.py

@@ -340,11 +340,13 @@ class BaseEmailLogger(CustomLogger):
         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:

litellm_enterprise-0.1.29/litellm_enterprise/proxy/__init__.py

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

{litellm_enterprise-0.1.27 → litellm_enterprise-0.1.29}/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.29/litellm_enterprise/proxy/common_utils/__init__.py

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

litellm_enterprise-0.1.29/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-0.1.27 → litellm_enterprise-0.1.29}/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(
@@ -244,6 +244,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]:
@@ -297,6 +369,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)
 
@@ -361,12 +435,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
@@ -382,6 +460,8 @@ class _PROXY_LiteLLMManagedFiles(CustomLogger, BaseFileEndpoints):
                 if retrieve_object_id
                 else False
             )
+            print(f"🔥potential_llm_object_id: {potential_llm_object_id}")
+            print(f"🔥retrieve_object_id: {retrieve_object_id}")
             if potential_llm_object_id and retrieve_object_id:
                 ## VALIDATE USER HAS ACCESS TO THE OBJECT ##
                 if not await self.can_user_call_unified_object_id(
@@ -673,6 +753,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
@@ -837,15 +918,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,
@@ -869,10 +971,13 @@ 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:
+            # 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():
-                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
@@ -880,6 +985,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")
 
@@ -946,7 +1054,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-0.1.27 → litellm_enterprise-0.1.29}/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.27 → litellm_enterprise-0.1.29}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "litellm-enterprise"
-version = "0.1.27"
+version = "0.1.29"
 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.27"
+version = "0.1.29"
 version_files = [
     "pyproject.toml:version",
     "../requirements.txt:litellm-enterprise==",