Validate outputs across all media endpoints

app/services/media_service.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import math
 import os
 import time
 from collections.abc import Awaitable, Callable, Sequence
@@ -8,6 +9,7 @@ from pathlib import Path
 from typing import Any
 
 from app.core.config import Settings
+from app.core.exceptions import ProcessingError
 from app.core.logger import get_logger
 from app.core.response import SuccessResponse
 from app.models.media import InputMedia, OperationResult, ResolvedRequest
@@ -244,6 +246,8 @@ class MediaProcessor:
         output_size = 0
         canonical_asset_id = None
         if result.path is not None:
+            output_report = await self.validate_output_result(result)
+            result.metadata = {**result.metadata, "output_validation": output_report}
             published = await self.cleanup.publish(
                 resolved.request_id, result.path, result.filename or result.path.name
             )
@@ -291,6 +295,72 @@ class MediaProcessor:
             metadata=metadata,
         )
 
+    async def validate_output_result(self, result: OperationResult) -> dict[str, Any]:
+        """Validate every published media artifact, regardless of which API produced it."""
+        path = result.path
+        if path is None:
+            return {"valid": True, "file_artifact": False}
+        if not path.is_file():
+            raise ProcessingError("Output artifact is missing")
+        try:
+            size = path.stat().st_size
+        except OSError as exc:
+            raise ProcessingError("Unable to inspect output artifact") from exc
+        if size <= 0:
+            raise ProcessingError("Output artifact is empty")
+
+        mime_type = result.mime_type or self.validator.infer_mime(path)
+        report: dict[str, Any] = {
+            "valid": True,
+            "file_artifact": True,
+            "size_bytes": size,
+            "mime_type": mime_type,
+            "probed": False,
+            "container": None,
+            "duration_seconds": None,
+            "video_stream_count": None,
+            "audio_stream_count": None,
+            "resolution": None,
+        }
+        if not mime_type.startswith(("audio/", "video/", "image/")):
+            return report
+
+        try:
+            probe = await self.ffprobe.probe(path)
+            self.validator.validate_probe(probe)
+        except Exception as exc:
+            if isinstance(exc, ProcessingError):
+                raise
+            raise ProcessingError("Output media failed integrity validation") from exc
+
+        video_streams = probe.get("video_streams") or []
+        audio_streams = probe.get("audio_streams") or []
+        if mime_type.startswith("video/") and not video_streams:
+            raise ProcessingError("Output is declared as video but contains no video stream")
+        if mime_type.startswith("audio/") and not audio_streams:
+            raise ProcessingError("Output is declared as audio but contains no audio stream")
+        if mime_type.startswith("image/") and not (video_streams or audio_streams):
+            raise ProcessingError("Output is declared as an image but contains no decodable stream")
+
+        duration = probe.get("duration")
+        if mime_type.startswith(("audio/", "video/")):
+            try:
+                valid_duration = duration is not None and math.isfinite(float(duration)) and float(duration) > 0
+            except (TypeError, ValueError):
+                valid_duration = False
+            if not valid_duration:
+                raise ProcessingError("Output media has an invalid duration")
+
+        report.update({
+            "probed": True,
+            "container": probe.get("container"),
+            "duration_seconds": duration,
+            "video_stream_count": len(video_streams),
+            "audio_stream_count": len(audio_streams),
+            "resolution": probe.get("resolution"),
+        })
+        return report
+
     @staticmethod
     def _optional_int(
         value: Any, name: str, minimum: int, maximum: int