diff --git a/litellm/proxy/guardrails/guardrail_hooks/airia/airia.py b/litellm/proxy/guardrails/guardrail_hooks/airia/airia.py index d41398e406c..df4aa9ef085 100644 --- a/litellm/proxy/guardrails/guardrail_hooks/airia/airia.py +++ b/litellm/proxy/guardrails/guardrail_hooks/airia/airia.py @@ -28,7 +28,7 @@ from litellm.proxy._types import UserAPIKeyAuth from litellm.proxy.guardrails.guardrail_hooks.unified_guardrail.unified_guardrail import UnifiedLLMGuardrails from litellm.types.guardrails import GuardrailEventHooks from litellm.types.proxy.guardrails.guardrail_hooks.airia import AiriaGuardrailConfigModel -from litellm.types.utils import MCP_GUARDRAIL_CALL_TYPES, CallTypesLiteral, GenericGuardrailAPIInputs +from litellm.types.utils import CallTypesLiteral, GenericGuardrailAPIInputs GUARDRAIL_PATH: Final = "/v1/guardrails/litellm" @@ -46,7 +46,13 @@ SUPPORTED_EVENT_HOOKS: Final = ( GuardrailEventHooks.post_mcp_call, ) +MCP_EVENT_HOOKS: Final = frozenset((GuardrailEventHooks.pre_mcp_call, GuardrailEventHooks.post_mcp_call)) +UNKNOWN_MCP_TOOL_NAME: Final = "unknown" + _EVALUATING_DURING_CALL: Final[ContextVar[bool]] = ContextVar("airia_evaluating_during_call", default=False) +# Request bodies on several routes are merged into the hook data, so MCP keys in it prove nothing; the event the +# framework gates on is the only signal a client cannot set +_PENDING_EVENT: Final[ContextVar[GuardrailEventHooks | None]] = ContextVar("airia_pending_event", default=None) def _stream_cannot_carry_a_rewrite(request_data: Mapping[str, object] | None) -> bool: @@ -93,20 +99,13 @@ def _request_route(request_data: Mapping[str, object]) -> str | None: return None -def _mcp_tool_name(request_data: Mapping[str, object], logging_obj: "LiteLLMLoggingObj | None") -> str | None: - """The MCP tool this evaluation is for, or None for model traffic. - - The logger's call type wins when there is one, because a chat client can put MCP keys in its request body. - """ - logged_call_type: Final[object] = getattr(logging_obj, "call_type", None) - if logging_obj is not None and logged_call_type not in MCP_GUARDRAIL_CALL_TYPES: - return None +def _mcp_tool_name(request_data: Mapping[str, object]) -> str: pre_call_name: Final = request_data.get("mcp_tool_name") if isinstance(pre_call_name, str) and pre_call_name: return pre_call_name call_metadata: Final = _as_object(request_data.get("mcp_tool_call_metadata")) post_call_name: Final = call_metadata.get("name") if call_metadata is not None else None - return post_call_name if isinstance(post_call_name, str) and post_call_name else None + return post_call_name if isinstance(post_call_name, str) and post_call_name else UNKNOWN_MCP_TOOL_NAME def _as_object(value: object) -> Mapping[str, object] | None: @@ -158,6 +157,15 @@ class AiriaGuardrail(CustomGuardrail): ) verbose_proxy_logger.info("AiriaGuardrail initialized with gateway: %s", self.api_base) + def should_run_guardrail( + self, + data: object, + event_type: GuardrailEventHooks, + ) -> bool: + runs: Final = super().should_run_guardrail(data, event_type) # pyright: ignore[reportUnknownMemberType] # the parent annotates data as untyped + _ = _PENDING_EVENT.set(event_type if runs else None) + return runs + def supports_structured_messages(self) -> bool: return False @@ -169,6 +177,8 @@ class AiriaGuardrail(CustomGuardrail): input_type: Literal["request", "response"], logging_obj: "LiteLLMLoggingObj | None" = None, ) -> GenericGuardrailAPIInputs: + is_mcp_tool_evaluation: Final = _PENDING_EVENT.get() in MCP_EVENT_HOOKS + _ = _PENDING_EVENT.set(None) call_id: Final = ( logging_obj.litellm_call_id if logging_obj @@ -187,7 +197,7 @@ class AiriaGuardrail(CustomGuardrail): "tool_calls": inputs.get("tool_calls") or (), "model": inputs.get("model"), "litellm_call_id": call_id, - "mcp_tool_name": _mcp_tool_name(request_data, logging_obj), + "mcp_tool_name": _mcp_tool_name(request_data or {}) if is_mcp_tool_evaluation else None, }, headers={"Authorization": f"Bearer {self.api_key}"}, ) diff --git a/tests/unit/proxy/guardrails/guardrail_hooks/test_airia.py b/tests/unit/proxy/guardrails/guardrail_hooks/test_airia.py index 57ba1ed0b33..4eb9e2fcaf0 100644 --- a/tests/unit/proxy/guardrails/guardrail_hooks/test_airia.py +++ b/tests/unit/proxy/guardrails/guardrail_hooks/test_airia.py @@ -21,6 +21,7 @@ from litellm.proxy.guardrails.init_guardrails import ( init_guardrails_v2, # pyright: ignore[reportUnknownVariableType] # untyped upstream ) from litellm.proxy.utils import ProxyLogging +from litellm.types.guardrails import GuardrailEventHooks from litellm.types.proxy.guardrails.guardrail_hooks.airia import AiriaGuardrailConfigModel from litellm.types.utils import GenericGuardrailAPIInputs @@ -188,28 +189,46 @@ async def test_post_mcp_call_redaction_masks_the_tool_result(monkeypatch: pytest @pytest.mark.asyncio -async def test_mcp_keys_in_a_chat_request_body_do_not_mark_it_as_a_tool_call() -> None: - guardrail: Final = _make_guardrail_with_response({"action": "NONE"}) - logging_obj: Final = LiteLLMLoggingObj( - model="gpt-4o", - messages=[], - stream=False, - call_type="acompletion", - start_time=datetime(2026, 1, 1, tzinfo=timezone.utc), - litellm_call_id="call-1", - function_id="1", +@pytest.mark.parametrize("logging_obj", [None, "acompletion"]) +async def test_mcp_keys_in_a_request_body_do_not_mark_model_traffic_as_a_tool_call(logging_obj: str | None) -> None: + guardrail: Final = _make_guardrail_with_response({"action": "NONE"}, event_hook="pre_call", default_on=True) + request_data: Final[dict[str, object]] = {"prompt": "draw a cat", "mcp_tool_name": "send_email"} + logger: Final = ( + LiteLLMLoggingObj( + model="gpt-4o", + messages=[], + stream=False, + call_type=logging_obj, + start_time=datetime(2026, 1, 1, tzinfo=timezone.utc), + litellm_call_id="call-1", + function_id="1", + ) + if logging_obj + else None ) + assert guardrail.should_run_guardrail(data=request_data, event_type=GuardrailEventHooks.pre_call) await guardrail.apply_guardrail( - inputs=_inputs(), - request_data={"mcp_tool_name": "send_email", "mcp_tool_call_metadata": {"name": "send_email"}}, - input_type="request", - logging_obj=logging_obj, + inputs=_inputs(), request_data=request_data, input_type="request", logging_obj=logger ) assert _post_mock(guardrail).call_args.kwargs["json"]["mcp_tool_name"] is None +@pytest.mark.asyncio +async def test_an_mcp_evaluation_does_not_mark_the_next_model_evaluation_as_a_tool_call() -> None: + guardrail: Final = _make_guardrail_with_response( + {"action": "NONE"}, event_hook=["pre_mcp_call", "pre_call"], default_on=True + ) + tool_call: Final[dict[str, object]] = {"mcp_tool_name": "send_email"} + assert guardrail.should_run_guardrail(data=tool_call, event_type=GuardrailEventHooks.pre_mcp_call) + await guardrail.apply_guardrail(inputs=_inputs(), request_data=tool_call, input_type="request") + + await guardrail.apply_guardrail(inputs=_inputs(), request_data=tool_call, input_type="request") + + assert _post_mock(guardrail).call_args.kwargs["json"]["mcp_tool_name"] is None + + def _during_call_request() -> dict[str, object]: return {"model": "gpt-4o", "messages": [{"role": "user", "content": "mail ada@example.com"}]}