feat: enable optional remote diarization

app/services/media_service.py

@@ -12,6 +12,7 @@ from app.core.logger import get_logger
 from app.core.response import SuccessResponse
 from app.models.media import InputMedia, OperationResult, ResolvedRequest
 from app.services.cleanup import CleanupService
+from app.services.diarization_service import DiarizationService
 from app.services.ffmpeg_service import FFmpegService
 from app.services.ffprobe_service import FFprobeService
 from app.services.input_resolver import InputResolver
@@ -40,6 +41,7 @@ class MediaProcessor:
         ytdlp: YTDLPService,
         whisper: WhisperService,
         assets: CanonicalAssetService | None = None,
+        diarization: DiarizationService | None = None,
     ) -> None:
         self.settings = settings
         self.resolver = resolver
@@ -50,6 +52,7 @@ class MediaProcessor:
         self.ytdlp = ytdlp
         self.whisper = whisper
         self.assets = assets
+        self.diarization = diarization or DiarizationService(settings)
 
     async def run(
         self, resolved: ResolvedRequest, operation_name: str, operation: Operation
@@ -89,11 +92,24 @@ class MediaProcessor:
             from app.core.exceptions import InputError
             raise InputError("beam_size must be between 1 and 20")
 
-        diarization = self._diarization(params.get("diarization"))
-        if diarization is None and len(inputs) > 1:
+        diarization_value = params.get("diarization")
+        diarization_source = "none"
+        diarization = self._diarization(diarization_value)
+
+        if diarization is not None:
+            diarization_source = "inline"
+        elif len(inputs) > 1:
             diarization = self._load_diarization_file(inputs[1])
+            diarization_source = "file"
+        elif self._bool(diarization_value, False):
+            diarization = await self.diarization.diarize(
+                inputs[0].temp_path,
+                inputs[0].mime_type,
+                inputs[0].filename,
+            )
+            diarization_source = "backend"
 
-        return await self.whisper.transcribe(
+        result = await self.whisper.transcribe(
             inputs[0].temp_path,
             output_dir,
             model_name=params.get("model"),
@@ -111,16 +127,28 @@ class MediaProcessor:
             diarization=diarization,
         )
 
+        result.metadata = {
+            **result.metadata,
+            "diarization_source": diarization_source,
+            "diarization_configured": self.diarization.is_configured,
+        }
+        return result
+
     @staticmethod
     def _diarization(value: Any) -> list[dict[str, Any]] | None:
         if value is None or value == "":
             return None
+        if isinstance(value, bool):
+            return None
         if isinstance(value, str):
+            stripped = value.strip()
+            if stripped.lower() in {"true", "1", "yes", "on"}:
+                return None
             try:
-                value = json.loads(value)
+                value = json.loads(stripped)
             except json.JSONDecodeError as exc:
                 from app.core.exceptions import InputError
-                raise InputError("diarization must be valid JSON") from exc
+                raise InputError("diarization must be valid JSON or a boolean flag") from exc
         if not isinstance(value, list):
             from app.core.exceptions import InputError
             raise InputError("diarization must be a JSON array of speaker spans")