Feat: update stt chirp3

.gitignore

@@ -24,4 +24,5 @@ convert_audio.py
 
 API_CONTRACT_CHATBOT.md
 API_CONTRACT_VOICE.md
-HIGHLIGHT_VOICE.md
+HIGHLIGHT_VOICE.md
+HIGHLIGHT_STT_TTS.md

main.py

@@ -2,16 +2,18 @@ import json
 import logging
 import uvicorn
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect, File, Form, UploadFile, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse, StreamingResponse
 from pydantic import BaseModel
 from src.pipeline import VoicePipeline
 from typing import Literal
 from src.config import (
     DEEPGRAM_API_KEY, CARTESIA_API_KEY, CARTESIA_VOICE_ID,
-    SAMPLE_RATE, GOOGLE_API_KEY, STT_PROVIDER, TTS_PROVIDER, WAKE_WORD_ENABLED,
+    SAMPLE_RATE, GOOGLE_API_KEY, GOOGLE_PROJECT_ID, STT_PROVIDER, TTS_PROVIDER, WAKE_WORD_ENABLED,
 )
 from src.stt.deepgram_rest import transcribe_audio as deepgram_transcribe
 from src.stt.gemini_stt import transcribe_audio as gemini_stt_transcribe
+from src.stt.chirp3_client import transcribe_audio as chirp3_transcribe
 from src.tts.cartesia_client import synthesize_stream as cartesia_synthesize
 from src.tts.gemini_client import synthesize_stream as gemini_synthesize, GEMINI_SAMPLE_RATE
 
@@ -22,6 +24,13 @@ VERSION = "1.2.0"
 
 app = FastAPI(title="Voice Agent Service", version=VERSION)
 
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
 
 @app.get("/")
 async def health() -> JSONResponse:
@@ -60,14 +69,18 @@ class TTSRequest(BaseModel):
 @app.post("/stt")
 async def speech_to_text(
     audio: UploadFile = File(...),
-    provider: str = Form(default="gemini"),
+    provider: str = Form(default="chirp3"),
 ) -> JSONResponse:
     data = await audio.read()
     if not data:
         raise HTTPException(status_code=400, detail="Audio file is empty.")
     mimetype = audio.content_type or "audio/wav"
 
-    if provider == "gemini":
+    if provider == "chirp3":
+        if not GOOGLE_PROJECT_ID:
+            raise HTTPException(status_code=503, detail="Chirp3 STT not configured: missing GOOGLE_PROJECT_ID.")
+        result = await chirp3_transcribe(data, mimetype=mimetype)
+    elif provider == "gemini":
         if not GOOGLE_API_KEY:
             raise HTTPException(status_code=503, detail="Gemini STT not configured: missing GOOGLE_API_KEY.")
         result = await gemini_stt_transcribe(data, mimetype=mimetype)
@@ -116,10 +129,16 @@ async def voice_ws(
     )
 
     async def send_audio(chunk: bytes) -> None:
-        await ws.send_bytes(chunk)
+        try:
+            await ws.send_bytes(chunk)
+        except WebSocketDisconnect:
+            pass
 
     async def send_event(event: dict) -> None:
-        await ws.send_text(json.dumps(event))
+        try:
+            await ws.send_text(json.dumps(event))
+        except WebSocketDisconnect:
+            pass
 
     tts_sample_rate = GEMINI_SAMPLE_RATE if tts_provider == "gemini" else SAMPLE_RATE
     await send_event({

src/stt/chirp3_client.py

@@ -17,6 +17,51 @@ OnTranscriptCallback = Callable[[str], Awaitable[None]]
 _CHUNK_SIZE = 24 * 1024  # stay under the 25 KB gRPC streaming limit
 
 
+async def transcribe_audio(data: bytes, mimetype: str = "audio/wav") -> dict:
+    """Transcribes a full audio file using Chirp 3 (Google Cloud Speech-to-Text V2)."""
+    def _run() -> str:
+        client = SpeechClient(
+            client_options=ClientOptions(
+                api_endpoint=f"{CHIRP3_REGION}-speech.googleapis.com"
+            )
+        )
+        chunks = [data[i: i + _CHUNK_SIZE] for i in range(0, len(data), _CHUNK_SIZE)]
+        audio_requests = (
+            cloud_speech_types.StreamingRecognizeRequest(audio=chunk)
+            for chunk in chunks
+        )
+        recognition_config = cloud_speech_types.RecognitionConfig(
+            auto_decoding_config=cloud_speech_types.AutoDetectDecodingConfig(),
+            language_codes=[CHIRP3_LANGUAGE],
+            model="chirp_3",
+        )
+        streaming_config = cloud_speech_types.StreamingRecognitionConfig(
+            config=recognition_config
+        )
+        config_request = cloud_speech_types.StreamingRecognizeRequest(
+            recognizer=f"projects/{GOOGLE_PROJECT_ID}/locations/{CHIRP3_REGION}/recognizers/_",
+            streaming_config=streaming_config,
+        )
+
+        def requests():
+            yield config_request
+            yield from audio_requests
+
+        transcripts: list[str] = []
+        for response in client.streaming_recognize(requests=requests()):
+            for result in response.results:
+                if result.alternatives:
+                    transcripts.append(result.alternatives[0].transcript)
+
+        transcript = " ".join(transcripts).strip()
+        if transcript:
+            logger.info("transcribe_audio/transcript: %s", transcript[:80])
+        return transcript
+
+    text = await asyncio.get_event_loop().run_in_executor(None, _run)
+    return {"text": text, "language": CHIRP3_LANGUAGE, "duration": None}
+
+
 class Chirp3STTStreamer:
     """
     Push-to-talk STT using Google Cloud Speech-to-Text V2 streaming with Chirp 3 model.