litellm-enterprise 0.1.18__tar.gz → 0.1.20__tar.gz

{litellm_enterprise-0.1.18 → litellm_enterprise-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: litellm-enterprise
-Version: 0.1.18
+Version: 0.1.20
 Summary: Package for LiteLLM Enterprise features
 Author: BerriAI
 Requires-Python: >=3.8, !=2.7.*, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*
@@ -9,7 +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
 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.18 → litellm_enterprise-0.1.20}/litellm_enterprise/enterprise_callbacks/llm_guard.py

@@ -63,7 +63,7 @@ class _ENTERPRISE_LLMGuard(CustomLogger):
                         analyze_url, json=analyze_payload
                     ) as response:
                         redacted_text = await response.json()
-                verbose_proxy_logger.info(
+                verbose_proxy_logger.debug(
                     f"LLM Guard: Received response - {redacted_text}"
                 )
                 if redacted_text is not None:

{litellm_enterprise-0.1.18 → litellm_enterprise-0.1.20}/litellm_enterprise/enterprise_callbacks/pagerduty/pagerduty.py

@@ -109,6 +109,9 @@ class PagerDutyAlerting(SlackAlerting):
                 error_llm_provider=error_info.get("llm_provider"),
                 user_api_key_hash=_meta.get("user_api_key_hash"),
                 user_api_key_alias=_meta.get("user_api_key_alias"),
+                user_api_key_spend=_meta.get("user_api_key_spend"),
+                user_api_key_max_budget=_meta.get("user_api_key_max_budget"),
+                user_api_key_budget_reset_at=_meta.get("user_api_key_budget_reset_at"),
                 user_api_key_org_id=_meta.get("user_api_key_org_id"),
                 user_api_key_team_id=_meta.get("user_api_key_team_id"),
                 user_api_key_user_id=_meta.get("user_api_key_user_id"),
@@ -191,6 +194,9 @@ class PagerDutyAlerting(SlackAlerting):
                 error_llm_provider="HangingRequest",
                 user_api_key_hash=user_api_key_dict.api_key,
                 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_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,

{litellm_enterprise-0.1.18 → litellm_enterprise-0.1.20}/litellm_enterprise/integrations/prometheus.py

@@ -95,13 +95,16 @@ class PrometheusLogger(CustomLogger):
             self.litellm_llm_api_time_to_first_token_metric = self._histogram_factory(
                 "litellm_llm_api_time_to_first_token_metric",
                 "Time to first token for a models LLM API call",
-                labelnames=[
-                    "model",
-                    "hashed_api_key",
-                    "api_key_alias",
-                    "team",
-                    "team_alias",
-                ],
+                # labelnames=[
+                #     "model",
+                #     "hashed_api_key",
+                #     "api_key_alias",
+                #     "team",
+                #     "team_alias",
+                # ],
+                labelnames=self.get_labels_for_metric(
+                    "litellm_llm_api_time_to_first_token_metric"
+                ),
                 buckets=LATENCY_BUCKETS,
             )
 
@@ -109,15 +112,7 @@ class PrometheusLogger(CustomLogger):
             self.litellm_spend_metric = self._counter_factory(
                 "litellm_spend_metric",
                 "Total spend on LLM requests",
-                labelnames=[
-                    "end_user",
-                    "hashed_api_key",
-                    "api_key_alias",
-                    "model",
-                    "team",
-                    "team_alias",
-                    "user",
-                ],
+                labelnames=self.get_labels_for_metric("litellm_spend_metric"),
             )
 
             # Counter for total_output_tokens
@@ -243,25 +238,18 @@ class PrometheusLogger(CustomLogger):
                 labelnames=["api_provider"],
             )
 
-            # Get all keys
-            _logged_llm_labels = [
-                UserAPIKeyLabelNames.v2_LITELLM_MODEL_NAME.value,
-                UserAPIKeyLabelNames.MODEL_ID.value,
-                UserAPIKeyLabelNames.API_BASE.value,
-                UserAPIKeyLabelNames.API_PROVIDER.value,
-            ]
-
             # Metric for deployment state
             self.litellm_deployment_state = self._gauge_factory(
                 "litellm_deployment_state",
                 "LLM Deployment Analytics - The state of the deployment: 0 = healthy, 1 = partial outage, 2 = complete outage",
-                labelnames=_logged_llm_labels,
+                labelnames=self.get_labels_for_metric("litellm_deployment_state"),
             )
 
             self.litellm_deployment_cooled_down = self._counter_factory(
                 "litellm_deployment_cooled_down",
                 "LLM Deployment Analytics - Number of times a deployment has been cooled down by LiteLLM load balancing logic. exception_status is the status of the exception that caused the deployment to be cooled down",
-                labelnames=_logged_llm_labels + [EXCEPTION_STATUS],
+                # labelnames=_logged_llm_labels + [EXCEPTION_STATUS],
+                labelnames=self.get_labels_for_metric("litellm_deployment_cooled_down"),
             )
 
             self.litellm_deployment_success_responses = self._counter_factory(
@@ -327,6 +315,7 @@ class PrometheusLogger(CustomLogger):
                 documentation="deprecated - use litellm_proxy_total_requests_metric. Total number of LLM calls to litellm - track total per API Key, team, user",
                 labelnames=self.get_labels_for_metric("litellm_requests_metric"),
             )
+
         except Exception as e:
             print_verbose(f"Got exception on init prometheus client {str(e)}")
             raise e
@@ -1052,20 +1041,12 @@ class PrometheusLogger(CustomLogger):
 
         _labels = prometheus_label_factory(
             supported_enum_labels=self.get_labels_for_metric(
-                metric_name="litellm_proxy_total_requests_metric"
+                metric_name="litellm_spend_metric"
             ),
             enum_values=enum_values,
         )
 
-        self.litellm_spend_metric.labels(
-            end_user_id,
-            user_api_key,
-            user_api_key_alias,
-            model,
-            user_api_team,
-            user_api_team_alias,
-            user_id,
-        ).inc(response_cost)
+        self.litellm_spend_metric.labels(**_labels).inc(response_cost)
 
     def _set_virtual_key_rate_limit_metrics(
         self,
@@ -2293,7 +2274,9 @@ def get_custom_labels_from_metadata(metadata: dict) -> Dict[str, str]:
     return result
 
 
-def _tag_matches_wildcard_configured_pattern(tags: List[str], configured_tag: str) -> bool:
+def _tag_matches_wildcard_configured_pattern(
+    tags: List[str], configured_tag: str
+) -> bool:
     """
     Check if any of the request tags matches a wildcard configured pattern
 
@@ -2318,6 +2301,7 @@ def _tag_matches_wildcard_configured_pattern(tags: List[str], configured_tag: st
     import re
 
     from litellm.router_utils.pattern_match_deployments import PatternMatchRouter
+
     pattern_router = PatternMatchRouter()
     regex_pattern = pattern_router._pattern_to_regex(configured_tag)
     return any(re.match(pattern=regex_pattern, string=tag) for tag in tags)
@@ -2326,11 +2310,11 @@ def _tag_matches_wildcard_configured_pattern(tags: List[str], configured_tag: st
 def get_custom_labels_from_tags(tags: List[str]) -> Dict[str, str]:
     """
     Get custom labels from tags based on admin configuration.
-    
+
     Supports both exact matches and wildcard patterns:
     - Exact match: "prod" matches "prod" exactly
-    - Wildcard pattern: "User-Agent: curl/*" matches "User-Agent: curl/7.68.0" 
-    
+    - Wildcard pattern: "User-Agent: curl/*" matches "User-Agent: curl/7.68.0"
+
     Reuses PatternMatchRouter for wildcard pattern matching.
 
     Returns dict of label_name: "true" if the tag matches the configured tag, "false" otherwise
@@ -2358,17 +2342,19 @@ def get_custom_labels_from_tags(tags: List[str]) -> Dict[str, str]:
 
     for configured_tag in configured_tags:
         label_name = _sanitize_prometheus_label_name(f"tag_{configured_tag}")
-        
+
         # Check for exact match first (backwards compatibility)
         if configured_tag in tags:
             result[label_name] = "true"
             continue
-            
+
         # Use PatternMatchRouter for wildcard pattern matching
-        if "*" in configured_tag and _tag_matches_wildcard_configured_pattern(tags=tags, configured_tag=configured_tag):
+        if "*" in configured_tag and _tag_matches_wildcard_configured_pattern(
+            tags=tags, configured_tag=configured_tag
+        ):
             result[label_name] = "true"
             continue
-        
+
         # No match found
         result[label_name] = "false"
 

{litellm_enterprise-0.1.18 → litellm_enterprise-0.1.20}/litellm_enterprise/proxy/management_endpoints/internal_user_endpoints.py

@@ -2,6 +2,8 @@
 Enterprise internal user management endpoints
 """
 
+import os
+
 from fastapi import APIRouter, Depends, HTTPException
 
 from litellm.proxy._types import UserAPIKeyAuth
@@ -21,7 +23,7 @@ async def available_enterprise_users(
     """
     For keys with `max_users` set, return the list of users that are allowed to use the key.
     """
-    from litellm.proxy._types import CommonProxyErrors
+    from litellm.proxy._types import CommonProxyErrors, EnterpriseLicenseData
     from litellm.proxy.proxy_server import (
         premium_user,
         premium_user_data,
@@ -34,10 +36,14 @@ async def available_enterprise_users(
             detail={"error": CommonProxyErrors.db_not_connected_error.value},
         )
 
-    if premium_user is None:
-        raise HTTPException(
-            status_code=500, detail={"error": CommonProxyErrors.not_premium_user.value}
-        )
+    if not premium_user:
+        # check if SSO is enabled - show 5 user limit
+        from litellm.proxy.auth.auth_utils import _has_user_setup_sso
+
+        if _has_user_setup_sso():
+            premium_user_data = EnterpriseLicenseData(
+                max_users=5,
+            )
 
     # Count number of rows in LiteLLM_UserTable
     user_count = await prisma_client.db.litellm_usertable.count()

{litellm_enterprise-0.1.18 → litellm_enterprise-0.1.20}/litellm_enterprise/types/proxy/proxy_server.py

@@ -1,4 +1,6 @@
-from typing import Literal, TypedDict
+from typing import Literal
+
+from typing_extensions import TypedDict
 
 
 class CustomAuthSettings(TypedDict):

{litellm_enterprise-0.1.18 → litellm_enterprise-0.1.20}/pyproject.toml

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

litellm_enterprise-0.1.18/litellm_enterprise/enterprise_callbacks/session_handler.py

@@ -1,160 +0,0 @@
-import json
-from typing import TYPE_CHECKING, Any, List, Optional, Union, cast
-
-from litellm._logging import verbose_proxy_logger
-from litellm.proxy._types import SpendLogsPayload
-from litellm.responses.utils import ResponsesAPIRequestUtils
-from litellm.types.llms.openai import (
-    AllMessageValues,
-    ChatCompletionResponseMessage,
-    GenericChatCompletionMessage,
-    ResponseInputParam,
-)
-from litellm.types.utils import ChatCompletionMessageToolCall, Message, ModelResponse
-
-if TYPE_CHECKING:
-    from litellm.responses.litellm_completion_transformation.transformation import (
-        ChatCompletionSession,
-    )
-else:
-    ChatCompletionSession = Any
-
-
-class _ENTERPRISE_ResponsesSessionHandler:
-    @staticmethod
-    async def get_chat_completion_message_history_for_previous_response_id(
-        previous_response_id: str,
-    ) -> ChatCompletionSession:
-        """
-        Return the chat completion message history for a previous response id
-        """
-        from litellm.responses.litellm_completion_transformation.transformation import (
-            ChatCompletionSession,
-            LiteLLMCompletionResponsesConfig,
-        )
-
-        verbose_proxy_logger.debug(
-            "inside get_chat_completion_message_history_for_previous_response_id"
-        )
-        all_spend_logs: List[
-            SpendLogsPayload
-        ] = await _ENTERPRISE_ResponsesSessionHandler.get_all_spend_logs_for_previous_response_id(
-            previous_response_id
-        )
-        verbose_proxy_logger.debug(
-            "found %s spend logs for this response id", len(all_spend_logs)
-        )
-
-        litellm_session_id: Optional[str] = None
-        if len(all_spend_logs) > 0:
-            litellm_session_id = all_spend_logs[0].get("session_id")
-
-        chat_completion_message_history: List[
-            Union[
-                AllMessageValues,
-                GenericChatCompletionMessage,
-                ChatCompletionMessageToolCall,
-                ChatCompletionResponseMessage,
-                Message,
-            ]
-        ] = []
-        for spend_log in all_spend_logs:
-            proxy_server_request: Union[str, dict] = (
-                spend_log.get("proxy_server_request") or "{}"
-            )
-            proxy_server_request_dict: Optional[dict] = None
-            response_input_param: Optional[Union[str, ResponseInputParam]] = None
-            if isinstance(proxy_server_request, dict):
-                proxy_server_request_dict = proxy_server_request
-            else:
-                proxy_server_request_dict = json.loads(proxy_server_request)
-
-            ############################################################
-            # Add Input messages for this Spend Log
-            ############################################################
-            if proxy_server_request_dict:
-                _response_input_param = proxy_server_request_dict.get("input", None)
-                if isinstance(_response_input_param, str):
-                    response_input_param = _response_input_param
-                elif isinstance(_response_input_param, dict):
-                    response_input_param = cast(
-                        ResponseInputParam, _response_input_param
-                    )
-
-            if response_input_param:
-                chat_completion_messages = LiteLLMCompletionResponsesConfig.transform_responses_api_input_to_messages(
-                    input=response_input_param,
-                    responses_api_request=proxy_server_request_dict or {},
-                )
-                chat_completion_message_history.extend(chat_completion_messages)
-
-            ############################################################
-            # Add Output messages for this Spend Log
-            ############################################################
-            _response_output = spend_log.get("response", "{}")
-            if isinstance(_response_output, dict):
-                # transform `ChatCompletion Response` to `ResponsesAPIResponse`
-                model_response = ModelResponse(**_response_output)
-                for choice in model_response.choices:
-                    if hasattr(choice, "message"):
-                        chat_completion_message_history.append(
-                            getattr(choice, "message")
-                        )
-
-        verbose_proxy_logger.debug(
-            "chat_completion_message_history %s",
-            json.dumps(chat_completion_message_history, indent=4, default=str),
-        )
-        return ChatCompletionSession(
-            messages=chat_completion_message_history,
-            litellm_session_id=litellm_session_id,
-        )
-
-    @staticmethod
-    async def get_all_spend_logs_for_previous_response_id(
-        previous_response_id: str,
-    ) -> List[SpendLogsPayload]:
-        """
-        Get all spend logs for a previous response id
-
-
-        SQL query
-
-        SELECT session_id FROM spend_logs WHERE response_id = previous_response_id, SELECT * FROM spend_logs WHERE session_id = session_id
-        """
-        from litellm.proxy.proxy_server import prisma_client
-
-        verbose_proxy_logger.debug("decoding response id=%s", previous_response_id)
-
-        decoded_response_id = (
-            ResponsesAPIRequestUtils._decode_responses_api_response_id(
-                previous_response_id
-            )
-        )
-        previous_response_id = decoded_response_id.get(
-            "response_id", previous_response_id
-        )
-        if prisma_client is None:
-            return []
-
-        query = """
-            WITH matching_session AS (
-                SELECT session_id
-                FROM "LiteLLM_SpendLogs"
-                WHERE request_id = $1
-            )
-            SELECT *
-            FROM "LiteLLM_SpendLogs"
-            WHERE session_id IN (SELECT session_id FROM matching_session)
-            ORDER BY "endTime" ASC;
-        """
-
-        spend_logs = await prisma_client.db.query_raw(query, previous_response_id)
-
-        verbose_proxy_logger.debug(
-            "Found the following spend logs for previous response id %s: %s",
-            previous_response_id,
-            json.dumps(spend_logs, indent=4, default=str),
-        )
-
-        return spend_logs