fix: openai moderation guardrails

litellm/proxy/guardrails/guardrail_hooks/openai/moderations.py

@@ -5,22 +5,17 @@
 
 from typing import (
     TYPE_CHECKING,
-    Any,
-    AsyncGenerator,
-    Dict,
-    List,
     Literal,
     Optional,
     Type,
-    Union,
 )
 
 from fastapi import HTTPException
 
 from litellm._logging import verbose_proxy_logger
 from litellm.integrations.custom_guardrail import (
     CustomGuardrail,
-    log_guardrail_information,
+    log_guardrail_information
 )
 from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
 from litellm.llms.custom_httpx.http_handler import (
@@ -32,10 +27,8 @@
 from .base import OpenAIGuardrailBase
 
 if TYPE_CHECKING:
-    from litellm.proxy._types import UserAPIKeyAuth
     from litellm.types.llms.openai import OpenAIModerationResponse
     from litellm.types.proxy.guardrails.guardrail_hooks.base import GuardrailConfigModel
-    from litellm.types.utils import ModelResponse, ModelResponseStream
 
 
 class OpenAIModerationGuardrail(OpenAIGuardrailBase, CustomGuardrail):
@@ -236,108 +229,6 @@ async def apply_guardrail(
         # Moderation doesn't modify content, just blocks - return inputs unchanged
         return inputs
 
-    @log_guardrail_information
-    async def async_post_call_streaming_iterator_hook(
-        self,
-        user_api_key_dict: "UserAPIKeyAuth",
-        response: Any,
-        request_data: Dict[str, Any],
-    ) -> AsyncGenerator["ModelResponseStream", None]:
-        """
-        Process streaming response chunks for OpenAI moderation.
-
-        Collects all chunks from the stream, assembles them into a complete response,
-        and applies moderation check. If content violates moderation policy, raises HTTPException.
-        """
-        # Import here to avoid circular imports
-        from litellm.llms.base_llm.base_model_iterator import MockResponseIterator
-        from litellm.main import stream_chunk_builder
-        from litellm.types.utils import TextCompletionResponse
-
-        verbose_proxy_logger.debug("OpenAI Moderation: Running streaming response scan")
-
-        # Collect all chunks to process them together
-        all_chunks: List["ModelResponseStream"] = []
-        async for chunk in response:
-            all_chunks.append(chunk)
-
-        # Assemble the complete response from chunks
-        assembled_model_response: Optional[
-            Union["ModelResponse", TextCompletionResponse]
-        ] = stream_chunk_builder(
-            chunks=all_chunks,
-        )
-
-        if isinstance(assembled_model_response, (type(None), TextCompletionResponse)):
-            # If we can't assemble a ModelResponse or it's a text completion,
-            # just yield the original chunks without moderation
-            verbose_proxy_logger.warning(
-                "OpenAI Moderation: Could not assemble ModelResponse from chunks, skipping moderation"
-            )
-            for chunk in all_chunks:
-                yield chunk
-            return
-
-        # Extract response text for moderation
-        response_text = self._extract_response_text(assembled_model_response)
-        if response_text:
-            verbose_proxy_logger.debug(
-                f"OpenAI Moderation: Streaming response text: {response_text[:100]}..."  # Log first 100 chars
-            )
-
-            # Make moderation request - this will raise HTTPException if content is flagged
-            moderation_response = await self.async_make_request(
-                input_text=response_text,
-            )
-
-            # Check if content is flagged and raise exception if needed
-            self._check_moderation_result(moderation_response)
-
-        # If we reach here, content passed moderation - yield the original chunks
-        mock_response = MockResponseIterator(model_response=assembled_model_response)
-
-        # Return the reconstructed stream
-        async for chunk in mock_response:
-            yield chunk
-
-    def _extract_response_text(self, response: "ModelResponse") -> Optional[str]:
-        """
-        Extract text content from the model response for moderation.
-        """
-        if not hasattr(response, "choices") or not response.choices:
-            return None
-
-        response_texts = []
-        for choice in response.choices:
-            try:
-                # Try to get content from message (chat completion)
-                message = getattr(choice, "message", None)
-                if message:
-                    content = getattr(message, "content", None)
-                    if content and isinstance(content, str):
-                        response_texts.append(content)
-                        continue
-
-                # Try to get text (text completion)
-                text = getattr(choice, "text", None)
-                if text and isinstance(text, str):
-                    response_texts.append(text)
-                    continue
-
-                # Try to get content from delta (streaming)
-                delta = getattr(choice, "delta", None)
-                if delta:
-                    content = getattr(delta, "content", None)
-                    if content and isinstance(content, str):
-                        response_texts.append(content)
-                        continue
-
-            except (AttributeError, TypeError):
-                # Skip choices that don't have expected attributes
-                continue
-
-        return "\n".join(response_texts) if response_texts else None
-
     @staticmethod
     def get_config_model() -> Optional[Type["GuardrailConfigModel"]]:
         """