update-

src/server/main.py

@@ -68,37 +68,6 @@ async def get_user_id_for_rate_limit(request: Request):
 limiter = Limiter(key_func=get_user_id_for_rate_limit)
 
 # Request/Response Models
-class SpeechRequest(BaseModel):
-    input: str = Field(..., description="Text to convert to speech (max 1000 characters)")
-    voice: str = Field(..., description="Voice identifier for the TTS service")
-    model: str = Field(..., description="TTS model to use")
-    response_format: ResponseFormat = Field(tts_config.response_format, description="Audio format: mp3, flac, or wav")
-    speed: float = Field(SPEED, description="Speech speed (default: 1.0)")
-
-    @field_validator("input")
-    def input_must_be_valid(cls, v):
-        if len(v) > 1000:
-            raise ValueError("Input cannot exceed 1000 characters")
-        return v.strip()
-
-    @field_validator("response_format")
-    def validate_response_format(cls, v):
-        supported_formats = [ResponseFormat.MP3, ResponseFormat.FLAC, ResponseFormat.WAV]
-        if v not in supported_formats:
-            raise ValueError(f"Response format must be one of {[fmt.value for fmt in supported_formats]}")
-        return v
-
-    class Config:
-        schema_extra = {
-            "example": {
-                "input": "Hello, how are you?",
-                "voice": "female-1",
-                "model": "tts-model-1",
-                "response_format": "mp3",
-                "speed": 1.0
-            }
-        }
-
 class TranscriptionResponse(BaseModel):
     text: str = Field(..., description="Transcribed text from the audio")
 
@@ -120,8 +89,9 @@ class AudioProcessingResponse(BaseModel):
 class ChatRequest(BaseModel):
     prompt: str = Field(..., description="Base64-encoded encrypted prompt (max 1000 characters after decryption)")
     src_lang: str = Field(..., description="Base64-encoded encrypted source language code")
+    tgt_lang: str = Field(..., description="Base64-encoded encrypted target language code")
 
-    @field_validator("prompt", "src_lang")
+    @field_validator("prompt", "src_lang", "tgt_lang")
     def must_be_valid_base64(cls, v):
         try:
             base64.b64decode(v)
@@ -133,7 +103,8 @@ class ChatRequest(BaseModel):
         schema_extra = {
             "example": {
                 "prompt": "base64_encoded_encrypted_prompt",
-                "src_lang": "base64_encoded_encrypted_kan_Knda"
+                "src_lang": "base64_encoded_encrypted_kan_Knda",
+                "tgt_lang": "base64_encoded_encrypted_kan_Knda"
             }
         }
 
@@ -213,16 +184,18 @@ class ExternalTTSService(TTSService):
     async def generate_speech(self, payload: dict) -> requests.Response:
         try:
             return requests.post(
-                settings.external_tts_url,
+                f"{settings.external_tts_url}/audio/speech",
                 json=payload,
-                headers={"accept": "application/json", "Content-Type": "application/json"},
+                headers={"accept": "*/*", "Content-Type": "application/json"},
                 stream=True,
                 timeout=60
             )
         except requests.Timeout:
+            logger.error("External TTS API timeout")
             raise HTTPException(status_code=504, detail="External TTS API timeout")
         except requests.RequestException as e:
-            raise HTTPException(status_code=500, detail=f"External TTS API error: {str(e)}")
+            logger.error(f"External TTS API error: {str(e)}")
+            raise HTTPException(status_code=502, detail=f"External TTS service error: {str(e)}")
 
 def get_tts_service() -> TTSService:
     return ExternalTTSService()
@@ -310,53 +283,68 @@ async def app_register_user(
 
 @app.post("/v1/audio/speech",
           summary="Generate Speech from Text",
-          description="Convert text to speech in the specified format using an external TTS service. Rate limited to 5 requests per minute per user. Requires authentication.",
+          description="Convert encrypted text to speech using an external TTS service. Rate limited to 5 requests per minute per user. Requires authentication and X-Session-Key header.",
           tags=["Audio"],
           responses={
               200: {"description": "Audio stream", "content": {"audio/mp3": {"example": "Binary audio data"}}},
-              400: {"description": "Invalid input"},
+              400: {"description": "Invalid or empty input"},
               401: {"description": "Unauthorized - Token required"},
               429: {"description": "Rate limit exceeded"},
+              502: {"description": "External TTS service unavailable"},
               504: {"description": "TTS service timeout"}
           })
 @limiter.limit(settings.speech_rate_limit)
 async def generate_audio(
     request: Request,
-    speech_request: SpeechRequest = Depends(),
+    input: str = Query(..., description="Base64-encoded encrypted text to convert to speech (max 1000 characters after decryption)"),
+    response_format: str = Query("mp3", description="Audio format (ignored, defaults to mp3 for external API)"),
     credentials: HTTPAuthorizationCredentials = Depends(bearer_scheme),
+    x_session_key: str = Header(..., alias="X-Session-Key"),
     tts_service: TTSService = Depends(get_tts_service)
 ):
     user_id = await get_current_user(credentials)
-    if not speech_request.input.strip():
+    session_key = base64.b64decode(x_session_key)
+    
+    # Decrypt input
+    try:
+        encrypted_input = base64.b64decode(input)
+        decrypted_input = decrypt_data(encrypted_input, session_key).decode("utf-8")
+    except Exception as e:
+        logger.error(f"Input decryption failed: {str(e)}")
+        raise HTTPException(status_code=400, detail="Invalid encrypted input")
+    
+    if not decrypted_input.strip():
         raise HTTPException(status_code=400, detail="Input cannot be empty")
+    if len(decrypted_input) > 1000:
+        raise HTTPException(status_code=400, detail="Decrypted input cannot exceed 1000 characters")
     
     logger.info("Processing speech request", extra={
         "endpoint": "/v1/audio/speech",
-        "input_length": len(speech_request.input),
+        "input_length": len(decrypted_input),
         "client_ip": get_remote_address(request),
         "user_id": user_id
     })
     
     payload = {
-        "input": speech_request.input,
-        "voice": speech_request.voice,
-        "model": speech_request.model,
-        "response_format": speech_request.response_format.value,
-        "speed": speech_request.speed
+        "text": decrypted_input
     }
     
-    response = await tts_service.generate_speech(payload)
-    response.raise_for_status()
+    try:
+        response = await tts_service.generate_speech(payload)
+        response.raise_for_status()
+    except requests.HTTPError as e:
+        logger.error(f"External TTS request failed: {str(e)}")
+        raise HTTPException(status_code=502, detail=f"External TTS service error: {str(e)}")
     
     headers = {
-        "Content-Disposition": f"inline; filename=\"speech.{speech_request.response_format.value}\"",
+        "Content-Disposition": "inline; filename=\"speech.mp3\"",
         "Cache-Control": "no-cache",
-        "Content-Type": f"audio/{speech_request.response_format.value}"
+        "Content-Type": "audio/mp3"
     }
     
     return StreamingResponse(
         response.iter_content(chunk_size=8192),
-        media_type=f"audio/{speech_request.response_format.value}",
+        media_type="audio/mp3",
         headers=headers
     )
 
@@ -398,6 +386,14 @@ async def chat(
         logger.error(f"Source language decryption failed: {str(e)}")
         raise HTTPException(status_code=400, detail="Invalid encrypted source language")
     
+    # Decrypt the target language
+    try:
+        encrypted_tgt_lang = base64.b64decode(chat_request.tgt_lang)
+        decrypted_tgt_lang = decrypt_data(encrypted_tgt_lang, session_key).decode("utf-8")
+    except Exception as e:
+        logger.error(f"Target language decryption failed: {str(e)}")
+        raise HTTPException(status_code=400, detail="Invalid encrypted target language")
+    
     if not decrypted_prompt:
         raise HTTPException(status_code=400, detail="Prompt cannot be empty")
     if len(decrypted_prompt) > 1000:
@@ -410,7 +406,7 @@ async def chat(
         payload = {
             "prompt": decrypted_prompt,
             "src_lang": decrypted_src_lang,
-            "tgt_lang": decrypted_src_lang
+            "tgt_lang": decrypted_tgt_lang
         }
         
         response = requests.post(