mirror of
https://github.com/BerriAI/litellm.git
synced 2026-11-04 07:27:51 +00:00
dfac770e2b
* feat(proxy): map baggage values to budget tags * fix(proxy): preserve mapped tags in the parsed request cache * fix(proxy): preserve mapper accounting and tag policy * fix(proxy): preserve baggage tags across native transports * fix(proxy): keep mapper rejection and passthrough logging safe * fix(proxy): scope baggage tag mappings to billed inference and keep them out of tag routing Mapped tags now apply only to billed LLM API routes, skipping token counting, model listing, MCP and A2A. They classify spend and budgets but never select deployments unless a key, team or client set the same tag. WebSocket inference returns 403 only while a required rule exists. A tag created with /tag/new resets its spend counter so its budget counts from creation. The General settings editor keeps a new mapping unsaved until every required field is filled in. * fix(proxy): keep client-tag rejection identical with baggage, map A2A calls, skip request previews * fix(proxy): keep mapped tags out of requester metadata, answer 503 on tag lookup errors, map custom pass-through routes, check the key before the WebSocket 403 * fix(proxy): keep caller-sent tags routable, keep mapped tags out of policy and guardrail matching, honor allow_requests_on_db_unavailable, reject control characters in baggage values * test(proxy): cover baggage tag mappings end to end Adds integration cells for request_tag_mappings across chat, messages, responses, A2A and custom pass-through spend, required and budgeted rules, the WebSocket refusal, unbilled routes, reject_clientside_metadata_tags, tag routing and policy isolation, a dropped tag read with and without allow_requests_on_db_unavailable, and the /tag/new spend counter reset * fix(proxy): keep base tag merges for requests that map nothing, accept JSON-string metadata tags, count litellm_metadata caller tags Requests with no mapped baggage now reuse the cached body exactly as before, so header and key tag merges still normalize metadata for routing. The client body copy is made only when a tag maps, and the base merges are mirrored onto it. A request that maps nothing no longer gets a 400 for non-object metadata. caller_tags now counts tags sent in both metadata and litellm_metadata. Optional mappings no longer reject JSON-string metadata tags under reject_clientside_metadata_tags. * fix(router): keep baggage-mapped tags from selecting tag-scoped pre-routing strategies Auto, complexity, adaptive and quality router selection, the consumed-tags stamp and compression policy lookup now read request tags without baggage-mapped tags, unless the caller sent the tag or the key, team or project carries it, matching deployment tag filtering. * feat(proxy): parse baggage headers into request tag mappings * fix(proxy): match plus-sign baggage keys and keep deployment tags in guardrail modes * fix(proxy): keep baggage-mapped tags behind key, team and deployment tags and serve non-object or invalid DB mapping settings like unset Mapped tags are added after the key, team, deployment and caller tags, so a tag-mode guardrail picks the same mode with or without baggage. A non-object metadata field maps like empty metadata, and an invalid request_tag_mappings value loaded from the DB is ignored with an ERROR log instead of failing every request * fix(router): merge deployment tags in linear time and keep malformed client tags as sent under mapped baggage Merge serving deployment tags into the request tags in one pass, so a large client tag list no longer blocks the event loop. Leave a non-list metadata.tags untouched when baggage maps a tag, so the request gets the same answer as without baggage. Add the C17 integration cell for the team tag's guardrail mode under a mapped deployment tag. * test(spend): cover string metadata.tags under mapped baggage * fix(proxy): check mapped tag budgets when metadata.tags is a non-list or holds non-strings Mapped baggage tags are applied again after the header and key tag merges, so a header or key tag that replaces a string metadata.tags no longer hides the mapped tag from the tag budget check. An empty or false metadata.tags is read like a missing one, and a tags list with non-string items is kept as sent with the mapped tags added after it, instead of failing auth with a 401
81 lines
2.9 KiB
Python
81 lines
2.9 KiB
Python
from typing import List, Optional, Union
|
|
|
|
from litellm.types.guardrails import GuardrailEventHooks, Mode
|
|
|
|
|
|
class EnterpriseCustomGuardrailHelper:
|
|
@staticmethod
|
|
def _should_run_if_mode_by_tag(
|
|
data: dict,
|
|
event_hook: Optional[
|
|
Union[GuardrailEventHooks, List[GuardrailEventHooks], Mode]
|
|
],
|
|
event_type: Optional[GuardrailEventHooks] = None,
|
|
) -> Optional[bool]:
|
|
"""
|
|
Returns True if the guardrail should be run for this request and event_type.
|
|
|
|
Logic:
|
|
- If a request tag matches a Mode tag key, only run if event_type matches
|
|
the tag's value (the mode for that tag).
|
|
- If no request tag matches, fall back to default mode(s).
|
|
"""
|
|
from litellm.litellm_core_utils.core_helpers import (
|
|
get_metadata_variable_name_from_kwargs,
|
|
)
|
|
from litellm.litellm_core_utils.litellm_logging import (
|
|
StandardLoggingPayloadSetup,
|
|
)
|
|
from litellm.router_strategy.tag_based_routing import (
|
|
without_baggage_mapped_tags,
|
|
)
|
|
from litellm.proxy._types import CommonProxyErrors
|
|
from litellm.proxy.proxy_server import premium_user
|
|
|
|
if not premium_user:
|
|
raise Exception(
|
|
f"Setting tag based guardrail modes is only available in litellm-enterprise. {CommonProxyErrors.not_premium_user.value}."
|
|
)
|
|
|
|
if event_hook is None or not isinstance(event_hook, Mode):
|
|
return None
|
|
|
|
proxy_server_request = data.get("proxy_server_request", {})
|
|
|
|
request_tags = without_baggage_mapped_tags(
|
|
StandardLoggingPayloadSetup.get_request_tags(
|
|
litellm_params=data,
|
|
proxy_server_request=proxy_server_request,
|
|
),
|
|
data.get(get_metadata_variable_name_from_kwargs(data)),
|
|
keep_serving_deployment_tags=True,
|
|
)
|
|
|
|
# Check if any request tag matches a Mode tag key
|
|
matched_mode = None
|
|
if request_tags:
|
|
for tag in request_tags:
|
|
if tag in event_hook.tags:
|
|
matched_mode = event_hook.tags[tag]
|
|
break
|
|
|
|
if matched_mode is not None:
|
|
# Tag matched: only run if event_type matches the tag's mode value(s)
|
|
if event_type is not None:
|
|
if isinstance(matched_mode, list):
|
|
return event_type.value in matched_mode
|
|
return event_type.value == matched_mode
|
|
return True
|
|
|
|
# No tag matched: fall back to default mode(s)
|
|
if event_hook.default is not None:
|
|
if event_type is not None:
|
|
default_list = (
|
|
event_hook.default
|
|
if isinstance(event_hook.default, list)
|
|
else [event_hook.default]
|
|
)
|
|
return event_type.value in default_list
|
|
return False
|
|
|
|
return False
|