chore(deps): update dependency deepgram-sdk to v6 (#32)

Author: renovate[bot]

api.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass
 from fastapi import APIRouter, Depends, FastAPI, HTTPException, UploadFile, File, Request
 from fastapi.concurrency import run_in_threadpool
 from fastapi.responses import StreamingResponse
@@ -11,8 +12,8 @@
 import sys
 import shutil
 import tempfile
-from deepgram import DeepgramClient, SpeakOptions
-from deepgram.clients.common.v1.errors import DeepgramApiError
+from deepgram import DeepgramClient
+from deepgram.core.api_error import ApiError
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 
 
@@ -129,6 +130,36 @@
     "aura-zeus-en",
 ]
 
+
+@dataclass(slots=True)
+class TTSOptions:
+    model: str | None = None
+    sample_rate: int | None = None
+    bit_rate: int | None = None
+    encoding: str | None = None
+    container: str | None = None
+    callback: str | None = None
+    callback_method: str | None = None
+    mip_opt_out: bool | None = None
+    tag: str | list[str] | None = None
+
+    def to_dict(self) -> dict:
+        return {
+            key: value
+            for key, value in {
+                "model": self.model,
+                "sample_rate": self.sample_rate,
+                "bit_rate": self.bit_rate,
+                "encoding": self.encoding,
+                "container": self.container,
+                "callback": self.callback,
+                "callback_method": self.callback_method,
+                "mip_opt_out": self.mip_opt_out,
+                "tag": self.tag,
+            }.items()
+            if value is not None
+        }
+
 def _iter_bytes(data: bytes, *, chunk_size: int):
     for i in range(0, len(data), chunk_size):
         yield data[i : i + chunk_size]
@@ -186,17 +217,19 @@ async def _concat_and_boost_mp3_ffmpeg(chunks: list[bytes], gain: float = 8.0) -
     return await run_in_threadpool(_concat_and_boost_mp3_ffmpeg_sync, chunks, gain)
 
 
-def _tts_chunk_to_bytes_sync(text: str, options: SpeakOptions) -> bytes:
-    """Synthesize a single text chunk via Deepgram SDK and return audio bytes."""
-    deepgram = DeepgramClient(DEEPGRAM_API_KEY)
-    timeout = httpx.Timeout(connect=10.0, read=300.0, write=300.0, pool=10.0)
-    response = deepgram.speak.rest.v("1").stream_memory(
-        {"text": text}, options, timeout=timeout
+def _tts_chunk_to_bytes_sync(text: str, options: TTSOptions) -> bytes:
+    """Synthesize a single text chunk via Deepgram SDK v6 and return audio bytes."""
+    deepgram = DeepgramClient(api_key=DEEPGRAM_API_KEY, timeout=300.0)
+    return b"".join(
+        deepgram.speak.v1.audio.generate(
+            text=text,
+            request_options={"timeout_in_seconds": 300, "chunk_size": 65536},
+            **options.to_dict(),
+        )
     )
-    return response.stream_memory.read()
 
 
-def _require_api_token_if_configured(request: Request) -> None:
+async def _require_api_token_if_configured(request: Request) -> None:
     configured_token = (os.getenv("API_TOKEN") or "").strip()
     if not configured_token:
         return
@@ -317,7 +350,7 @@ async def get_speech(request: Request):
             raise HTTPException(status_code=400, detail=f"No TTS model available for language: {language}")
         input_params["model"] = models[0]
 
-    # Build SpeakOptions with valid TTS parameters
+    # Build TTS options with only Deepgram-supported TTS parameters.
     speak_kwargs = {}
     if input_params.get("model"):
         speak_kwargs["model"] = input_params["model"]
@@ -326,8 +359,16 @@ async def get_speech(request: Request):
     if input_params.get("bit_rate"):
         speak_kwargs["bit_rate"] = int(input_params["bit_rate"])
     speak_kwargs["encoding"] = "mp3"
-
-    options = SpeakOptions(**speak_kwargs)
+    if input_params.get("callback"):
+        speak_kwargs["callback"] = input_params["callback"]
+    if input_params.get("callback_method"):
+        speak_kwargs["callback_method"] = input_params["callback_method"]
+    if input_params.get("mip_opt_out"):
+        speak_kwargs["mip_opt_out"] = input_params["mip_opt_out"].strip().lower() in ("1", "true", "yes")
+    if input_params.get("tag"):
+        speak_kwargs["tag"] = input_params["tag"]
+
+    options = TTSOptions(**speak_kwargs)
     logger.debug("Deepgram TTS options: %s", speak_kwargs)
 
     audio_parts: list[bytes] = []
@@ -341,12 +382,13 @@ async def get_speech(request: Request):
                 idx, len(chunks), len(audio_data),
             )
             audio_parts.append(audio_data)
-    except DeepgramApiError as e:
-        status = int(e.status) if e.status else 502
-        logger.error("Deepgram TTS API error: status=%s message=%s", e.status, e.message)
+    except ApiError as e:
+        status = int(e.status_code) if e.status_code else 502
+        message = e.body if isinstance(e.body, str) else str(e.body)
+        logger.error("Deepgram TTS API error: status=%s message=%s", e.status_code, message)
         raise HTTPException(
             status_code=status,
-            detail=f"Deepgram API error: {e.message}",
+            detail=f"Deepgram API error: {message}",
         )
     except httpx.TimeoutException:
         logger.warning("Deepgram TTS request timed out")

requirements.txt

@@ -1,6 +1,6 @@
 aiohttp
 aiomqtt
-deepgram-sdk==3.*
+deepgram-sdk==6.*
 fastapi
 langchain
 langchain_openai

tests/test_api.py

@@ -493,9 +493,9 @@ def test_get_speech_deepgram_timeout_returns_504(self, mock_tts, client):
 
     @patch("api._tts_chunk_to_bytes_sync")
     def test_get_speech_deepgram_http_error_propagates_status(self, mock_tts, client):
-        from deepgram.clients.common.v1.errors import DeepgramApiError
+        from deepgram.core.api_error import ApiError
 
-        mock_tts.side_effect = DeepgramApiError("Invalid API key", "401")
+        mock_tts.side_effect = ApiError(status_code=401, body="Invalid API key")
 
         response = client.post("/api/get_speech", data={"text": "hello"})
         assert response.status_code == 401