add gemini api

config.py

@@ -16,7 +16,7 @@ HUGGINGFACE_API_KEY = os.getenv("HUGGINGFACE_API_KEY", "")
 
 HUGGINGFACE_STANCE_MODEL_ID = os.getenv("HUGGINGFACE_STANCE_MODEL_ID")
 HUGGINGFACE_LABEL_MODEL_ID = os.getenv("HUGGINGFACE_LABEL_MODEL_ID")
-HUGGINGFACE_STT_MODEL_ID = os.getenv("HUGGINGFACE_STT_MODEL_ID", "openai/whisper-large-v3")
+HUGGINGFACE_STT_MODEL_ID = os.getenv("HUGGINGFACE_STT_MODEL_ID")
 
 # Use Hugging Face model ID instead of local path
 STANCE_MODEL_ID = HUGGINGFACE_STANCE_MODEL_ID

routes/audio.py

@@ -1,84 +1,25 @@
-"""Speech-to-Text & Text-to-Speech API Endpoints"""
-
-from fastapi import APIRouter, UploadFile, File, HTTPException
-from fastapi.responses import StreamingResponse
-import logging
-
-from models.audio import (
-    STTResponse,
-    TTSRequest,
-    TTSResponse
-)
-
-from services.stt_service import transcribe_audio
-from services.tts_service import text_to_speech
+from fastapi import APIRouter, UploadFile, File
+from services.tts_service import generate_tts
+from services.stt_service import speech_to_text
+from fastapi.responses import FileResponse
+import uuid
 
 router = APIRouter(prefix="/audio", tags=["Audio"])
-logger = logging.getLogger(__name__)
-
-
-# ============================================================
-# SPEECH TO TEXT (Whisper)
-# ============================================================
-
-@router.post("/speech-to-text", response_model=STTResponse)
-async def speech_to_text_endpoint(file: UploadFile = File(...)):
-    """
-    Convert speech to text using openai/whisper-large-v3.
-
-    - Upload an audio file (wav, mp3, m4a…)
-    - Returns transcribed English text
-    """
-    try:
-        audio_bytes = await file.read()
-
-        result = transcribe_audio(audio_bytes)
-
-        response_data = STTResponse(
-            text=result,
-            model_name="openai/whisper-large-v3",
-            language="en",
-            duration_seconds=None  # optional filler
-        )
-
-        logger.info(f"STT completed: {response_data.text[:40]}...")
-        return response_data
-
-    except Exception as e:
-        logger.error(f"STT error: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Speech-to-text failed: {str(e)}")
-
 
-# ============================================================
-# TEXT TO SPEECH (Bark)
-# ============================================================
 
-@router.post("/text-to-speech", response_model=TTSResponse)
-async def text_to_speech_endpoint(request: TTSRequest):
-    """
-    Convert text to synthesized speech using Bark.
-    Returns streamed audio.
-    """
-    try:
-        audio_bytes = text_to_speech(request.text)
+@router.post("/tts")
+async def tts(text: str):
+    audio_bytes = await generate_tts(text)
 
-        metadata = TTSResponse(
-            message="Audio generated successfully",
-            audio_format="wav",
-            length_seconds=None,
-            model_name="suno/bark"
-        )
+    filename = f"tts_{uuid.uuid4()}.wav"
+    with open(filename, "wb") as f:
+        f.write(audio_bytes)
 
-        logger.info(f"TTS generated for text: {request.text[:40]}...")
+    return FileResponse(filename, media_type="audio/wav", filename=filename)
 
-        return StreamingResponse(
-            iter([audio_bytes]),
-            media_type="audio/wav",
-            headers={
-                "X-Audio-Metadata": metadata.model_dump_json()
-            }
-        )
 
-    except Exception as e:
-        logger.error(f"TTS error: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Text-to-speech failed: {str(e)}")
+@router.post("/stt")
+async def stt(file: UploadFile = File(...)):
+    audio_bytes = await file.read()
+    text = await speech_to_text(audio_bytes)
+    return {"text": text}

services/__init__.py

@@ -3,9 +3,19 @@
 from .stance_model_manager import StanceModelManager, stance_model_manager
 from .label_model_manager import KpaModelManager, kpa_model_manager
 
+# NEW imports
+from .stt_service import speech_to_text
+from .tts_service import generate_tts
+from .gemini_client import get_gemini_client
+
 __all__ = [
     "StanceModelManager",
     "stance_model_manager",
     "KpaModelManager",
     "kpa_model_manager",
+
+    # NEW exports
+    "speech_to_text",
+    "generate_tts",
+    "get_gemini_client",
 ]

services/gemini_client.py

@@ -0,0 +1,3 @@
+from google import genai
+
+client = genai.Client()

services/stt_service.py

@@ -1,24 +1,18 @@
-# services/stt_service.py
+from services.gemini_client import get_gemini_client
 
-import requests
-from config import HUGGINGFACE_API_KEY, HUGGINGFACE_STT_MODEL_ID
 
-def transcribe_audio(file_bytes: bytes) -> str:
-    """
-    Convert audio bytes into English text using Whisper large-v3
-    through Hugging Face Inference API.
-    """
-    headers = {
-        "Authorization": f"Bearer {HUGGINGFACE_API_KEY}",
-        "Content-Type": "application/octet-stream",
-    }
+async def speech_to_text(audio_bytes: bytes) -> str:
+    client = get_gemini_client()
 
-    url = f"https://api-inference.huggingface.co/models/{HUGGINGFACE_STT_MODEL_ID}"
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents=[
+            {
+                "mime_type": "audio/wav",
+                "data": audio_bytes
+            }
+        ]
+    )
 
-    response = requests.post(url, headers=headers, data=file_bytes)
-
-    try:
-        result = response.json()
-        return result.get("text", "Error: No transcription returned.")
-    except Exception:
-        return "Error: Invalid response from STT model."
+    text = response.text
+    return text

services/tts_service.py

@@ -1,28 +1,33 @@
-import requests
-from config import HUGGINGFACE_API_KEY
+from google.genai import types
+from services.gemini_client import get_gemini_client
+import wave
 
-# Bark model
-BARK_MODEL_ID = "suno/bark"
 
-def text_to_speech(text: str) -> bytes:
-    """
-    Convert text to speech (audio bytes) using Hugging Face Bark model.
-    """
-    url = f"https://api-inference.huggingface.co/models/{BARK_MODEL_ID}"
+def save_wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
+    with wave.open(filename, "wb") as wf:
+        wf.setnchannels(channels)
+        wf.setsampwidth(sample_width)
+        wf.setframerate(rate)
+        wf.writeframes(pcm)
 
-    headers = {
-        "Authorization": f"Bearer {HUGGINGFACE_API_KEY}",
-        "Content-Type": "application/json"
-    }
 
-    payload = {
-        "inputs": text
-    }
+async def generate_tts(text: str) -> bytes:
+    client = get_gemini_client()
 
-    response = requests.post(url, headers=headers, json=payload)
+    response = client.models.generate_content(
+        model="gemini-2.5-flash-preview-tts",
+        contents=text,
+        config=types.GenerateContentConfig(
+            response_modalities=["AUDIO"],
+            speech_config=types.SpeechConfig(
+                voice_config=types.VoiceConfig(
+                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                        voice_name="Kore"
+                    )
+                )
+            ),
+        ),
+    )
 
-    # Bark returns raw WAV bytes
-    if response.status_code != 200:
-        raise Exception(f"Bark API error: {response.text}")
-
-    return response.content
+    audio_bytes = response.candidates[0].content.parts[0].inline_data.data
+    return audio_bytes