litellm-enterprise 0.1.22__tar.gz → 0.1.24__tar.gz

{litellm_enterprise-0.1.22 → litellm_enterprise-0.1.24}/PKG-INFO

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

litellm_enterprise-0.1.24/litellm_enterprise/enterprise_callbacks/send_emails/sendgrid_email.py

@@ -0,0 +1,79 @@
+"""
+LiteLLM x SendGrid email integration.
+
+Docs: https://docs.sendgrid.com/api-reference/mail-send/mail-send
+"""
+
+import os
+from typing import List
+
+from litellm._logging import verbose_logger
+from litellm.llms.custom_httpx.http_handler import (
+    get_async_httpx_client,
+    httpxSpecialProvider,
+)
+
+from .base_email import BaseEmailLogger
+
+
+SENDGRID_API_ENDPOINT = "https://api.sendgrid.com/v3/mail/send"
+
+
+class SendGridEmailLogger(BaseEmailLogger):
+    """
+    Send emails using SendGrid's Mail Send API.
+
+    Required env vars:
+    - SENDGRID_API_KEY
+    """
+
+    def __init__(self):
+        self.async_httpx_client = get_async_httpx_client(
+            llm_provider=httpxSpecialProvider.LoggingCallback
+        )
+        self.sendgrid_api_key = os.getenv("SENDGRID_API_KEY")
+        verbose_logger.debug("SendGrid Email Logger initialized.")
+
+    async def send_email(
+        self,
+        from_email: str,
+        to_email: List[str],
+        subject: str,
+        html_body: str,
+    ):
+        """
+        Send an email via SendGrid.
+        """
+        if not self.sendgrid_api_key:
+            raise ValueError("SENDGRID_API_KEY is not set")
+
+        verbose_logger.debug(
+            f"Sending email via SendGrid from {from_email} to {to_email} with subject {subject}"
+        )
+
+        payload = {
+            "from": {"email": from_email},
+            "personalizations": [
+                {
+                    "to": [{"email": email} for email in to_email],
+                    "subject": subject,
+                }
+            ],
+            "content": [
+                {
+                    "type": "text/html",
+                    "value": html_body,
+                }
+            ],
+        }
+
+        response = await self.async_httpx_client.post(
+            url=SENDGRID_API_ENDPOINT,
+            json=payload,
+            headers={"Authorization": f"Bearer {self.sendgrid_api_key}"},
+        )
+
+        verbose_logger.debug(
+            f"SendGrid response status={response.status_code}, body={response.text}"
+        )
+        return

{litellm_enterprise-0.1.22 → litellm_enterprise-0.1.24}/litellm_enterprise/proxy/enterprise_routes.py

@@ -5,14 +5,10 @@ from litellm_enterprise.enterprise_callbacks.send_emails.endpoints import (
 )
 
 from .audit_logging_endpoints import router as audit_logging_router
-from .guardrails.endpoints import router as guardrails_router
 from .management_endpoints import management_endpoints_router
 from .utils import _should_block_robots
-from .vector_stores.endpoints import router as vector_stores_router
 
 router = APIRouter()
-router.include_router(vector_stores_router)
-router.include_router(guardrails_router)
 router.include_router(email_events_router)
 router.include_router(audit_logging_router)
 router.include_router(management_endpoints_router)

{litellm_enterprise-0.1.22 → litellm_enterprise-0.1.24}/litellm_enterprise/proxy/vector_stores/endpoints.py

@@ -141,28 +141,36 @@ async def list_vector_stores(
     """
     from litellm.proxy.proxy_server import prisma_client
 
-    seen_vector_store_ids = set()
-
     try:
-        # Get in-memory vector stores
-        in_memory_vector_stores: List[LiteLLM_ManagedVectorStore] = []
-        if litellm.vector_store_registry is not None:
-            in_memory_vector_stores = copy.deepcopy(
-                litellm.vector_store_registry.vector_stores
-            )
-
-        # Get vector stores from database
+        # Get vector stores from database (source of truth)
+        # Only return what's in the database to ensure consistency across instances
         vector_stores_from_db = await VectorStoreRegistry._get_vector_stores_from_db(
             prisma_client=prisma_client
         )
+        
+        # Also clean up in-memory registry to remove any deleted vector stores
+        if litellm.vector_store_registry is not None:
+            db_vector_store_ids = {
+                vs.get("vector_store_id") 
+                for vs in vector_stores_from_db 
+                if vs.get("vector_store_id")
+            }
+            # Remove any in-memory vector stores that no longer exist in database
+            vector_stores_to_remove = []
+            for vs in litellm.vector_store_registry.vector_stores:
+                vs_id = vs.get("vector_store_id")
+                if vs_id and vs_id not in db_vector_store_ids:
+                    vector_stores_to_remove.append(vs_id)
+            for vs_id in vector_stores_to_remove:
+                litellm.vector_store_registry.delete_vector_store_from_registry(
+                    vector_store_id=vs_id
+                )
+                verbose_proxy_logger.debug(
+                    f"Removed deleted vector store {vs_id} from in-memory registry"
+                )
 
-        # Combine in-memory and database vector stores
-        combined_vector_stores: List[LiteLLM_ManagedVectorStore] = []
-        for vector_store in in_memory_vector_stores + vector_stores_from_db:
-            vector_store_id = vector_store.get("vector_store_id", None)
-            if vector_store_id not in seen_vector_store_ids:
-                combined_vector_stores.append(vector_store)
-                seen_vector_store_ids.add(vector_store_id)
+        # Use database as single source of truth for listing
+        combined_vector_stores: List[LiteLLM_ManagedVectorStore] = vector_stores_from_db
 
         total_count = len(combined_vector_stores)
         total_pages = (total_count + page_size - 1) // page_size

{litellm_enterprise-0.1.22 → litellm_enterprise-0.1.24}/pyproject.toml

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

litellm_enterprise-0.1.22/litellm_enterprise/enterprise_callbacks/generic_api_callback.py

@@ -1,266 +0,0 @@
-"""
-Callback to log events to a Generic API Endpoint
-
-- Creates a StandardLoggingPayload
-- Adds to batch queue
-- Flushes based on CustomBatchLogger settings
-"""
-
-import asyncio
-import os
-import traceback
-from litellm._uuid import uuid
-from typing import Dict, List, Optional, Union
-
-import litellm
-from litellm._logging import verbose_logger
-from litellm.integrations.custom_batch_logger import CustomBatchLogger
-from litellm.litellm_core_utils.safe_json_dumps import safe_dumps
-from litellm.llms.custom_httpx.http_handler import (
-    get_async_httpx_client,
-    httpxSpecialProvider,
-)
-from litellm.types.utils import StandardLoggingPayload
-
-
-class GenericAPILogger(CustomBatchLogger):
-    def __init__(
-        self,
-        endpoint: Optional[str] = None,
-        headers: Optional[dict] = None,
-        **kwargs,
-    ):
-        """
-        Initialize the GenericAPILogger
-
-        Args:
-            endpoint: Optional[str] = None,
-            headers: Optional[dict] = None,
-        """
-        #########################################################
-        # Init httpx client
-        #########################################################
-        self.async_httpx_client = get_async_httpx_client(
-            llm_provider=httpxSpecialProvider.LoggingCallback
-        )
-        endpoint = endpoint or os.getenv("GENERIC_LOGGER_ENDPOINT")
-        if endpoint is None:
-            raise ValueError(
-                "endpoint not set for GenericAPILogger, GENERIC_LOGGER_ENDPOINT not found in environment variables"
-            )
-
-        self.headers: Dict = self._get_headers(headers)
-        self.endpoint: str = endpoint
-        verbose_logger.debug(
-            f"in init GenericAPILogger, endpoint {self.endpoint}, headers {self.headers}"
-        )
-
-        #########################################################
-        # Init variables for batch flushing logs
-        #########################################################
-        self.flush_lock = asyncio.Lock()
-        super().__init__(**kwargs, flush_lock=self.flush_lock)
-        asyncio.create_task(self.periodic_flush())
-        self.log_queue: List[Union[Dict, StandardLoggingPayload]] = []
-
-    def _get_headers(self, headers: Optional[dict] = None):
-        """
-        Get headers for the Generic API Logger
-
-        Returns:
-            Dict: Headers for the Generic API Logger
-
-        Args:
-            headers: Optional[dict] = None
-        """
-        # Process headers from different sources
-        headers_dict = {
-            "Content-Type": "application/json",
-        }
-
-        # 1. First check for headers from env var
-        env_headers = os.getenv("GENERIC_LOGGER_HEADERS")
-        if env_headers:
-            try:
-                # Parse headers in format "key1=value1,key2=value2" or "key1=value1"
-                header_items = env_headers.split(",")
-                for item in header_items:
-                    if "=" in item:
-                        key, value = item.split("=", 1)
-                        headers_dict[key.strip()] = value.strip()
-            except Exception as e:
-                verbose_logger.warning(
-                    f"Error parsing headers from environment variables: {str(e)}"
-                )
-
-        # 2. Update with litellm generic headers if available
-        if litellm.generic_logger_headers:
-            headers_dict.update(litellm.generic_logger_headers)
-
-        # 3. Override with directly provided headers if any
-        if headers:
-            headers_dict.update(headers)
-
-        return headers_dict
-
-    async def async_log_success_event(self, kwargs, response_obj, start_time, end_time):
-        """
-        Async Log success events to Generic API Endpoint
-
-        - Creates a StandardLoggingPayload
-        - Adds to batch queue
-        - Flushes based on CustomBatchLogger settings
-
-        Raises:
-            Raises a NON Blocking verbose_logger.exception if an error occurs
-        """
-        from litellm.proxy.utils import _premium_user_check
-
-        _premium_user_check()
-
-        try:
-            verbose_logger.debug(
-                "Generic API Logger - Enters logging function for model %s", kwargs
-            )
-            standard_logging_payload = kwargs.get("standard_logging_object", None)
-
-            # Backwards compatibility with old logging payload
-            if litellm.generic_api_use_v1 is True:
-                payload = self._get_v1_logging_payload(
-                    kwargs=kwargs,
-                    response_obj=response_obj,
-                    start_time=start_time,
-                    end_time=end_time,
-                )
-                self.log_queue.append(payload)
-            else:
-                # New logging payload, StandardLoggingPayload
-                self.log_queue.append(standard_logging_payload)
-
-            if len(self.log_queue) >= self.batch_size:
-                await self.async_send_batch()
-
-        except Exception as e:
-            verbose_logger.exception(
-                f"Generic API Logger Error - {str(e)}\n{traceback.format_exc()}"
-            )
-            pass
-
-    async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
-        """
-        Async Log failure events to Generic API Endpoint
-
-        - Creates a StandardLoggingPayload
-        - Adds to batch queue
-        """
-        from litellm.proxy.utils import _premium_user_check
-
-        _premium_user_check()
-
-        try:
-            verbose_logger.debug(
-                "Generic API Logger - Enters logging function for model %s", kwargs
-            )
-            standard_logging_payload = kwargs.get("standard_logging_object", None)
-
-            if litellm.generic_api_use_v1 is True:
-                payload = self._get_v1_logging_payload(
-                    kwargs=kwargs,
-                    response_obj=response_obj,
-                    start_time=start_time,
-                    end_time=end_time,
-                )
-                self.log_queue.append(payload)
-            else:
-                self.log_queue.append(standard_logging_payload)
-
-            if len(self.log_queue) >= self.batch_size:
-                await self.async_send_batch()
-
-        except Exception as e:
-            verbose_logger.exception(
-                f"Generic API Logger Error - {str(e)}\n{traceback.format_exc()}"
-            )
-
-    async def async_send_batch(self):
-        """
-        Sends the batch of messages to Generic API Endpoint
-        """
-        try:
-            if not self.log_queue:
-                return
-
-            verbose_logger.debug(
-                f"Generic API Logger - about to flush {len(self.log_queue)} events"
-            )
-
-            # make POST request to Generic API Endpoint
-            response = await self.async_httpx_client.post(
-                url=self.endpoint,
-                headers=self.headers,
-                data=safe_dumps(self.log_queue),
-            )
-
-            verbose_logger.debug(
-                f"Generic API Logger - sent batch to {self.endpoint}, status code {response.status_code}"
-            )
-
-        except Exception as e:
-            verbose_logger.exception(
-                f"Generic API Logger Error sending batch - {str(e)}\n{traceback.format_exc()}"
-            )
-        finally:
-            self.log_queue.clear()
-
-    def _get_v1_logging_payload(
-        self, kwargs, response_obj, start_time, end_time
-    ) -> dict:
-        """
-        Maintained for backwards compatibility with old logging payload
-
-        Returns a dict of the payload to send to the Generic API Endpoint
-        """
-        verbose_logger.debug(
-            f"GenericAPILogger Logging - Enters logging function for model {kwargs}"
-        )
-
-        # construct payload to send custom logger
-        # follows the same params as langfuse.py
-        litellm_params = kwargs.get("litellm_params", {})
-        metadata = (
-            litellm_params.get("metadata", {}) or {}
-        )  # if litellm_params['metadata'] == None
-        messages = kwargs.get("messages")
-        cost = kwargs.get("response_cost", 0.0)
-        optional_params = kwargs.get("optional_params", {})
-        call_type = kwargs.get("call_type", "litellm.completion")
-        cache_hit = kwargs.get("cache_hit", False)
-        usage = response_obj["usage"]
-        id = response_obj.get("id", str(uuid.uuid4()))
-
-        # Build the initial payload
-        payload = {
-            "id": id,
-            "call_type": call_type,
-            "cache_hit": cache_hit,
-            "startTime": start_time,
-            "endTime": end_time,
-            "model": kwargs.get("model", ""),
-            "user": kwargs.get("user", ""),
-            "modelParameters": optional_params,
-            "messages": messages,
-            "response": response_obj,
-            "usage": usage,
-            "metadata": metadata,
-            "cost": cost,
-        }
-
-        # Ensure everything in the payload is converted to str
-        for key, value in payload.items():
-            try:
-                payload[key] = str(value)
-            except Exception:
-                # non blocking if it can't cast to a str
-                pass
-
-        return payload