fix

src/server/main.py

@@ -119,21 +119,21 @@ class AudioProcessingResponse(BaseModel):
 
 class ChatRequest(BaseModel):
     prompt: str = Field(..., description="Base64-encoded encrypted prompt (max 1000 characters after decryption)")
-    src_lang: str = Field("kan_Knda", description="Source language code (default: Kannada)")
+    src_lang: str = Field(..., description="Base64-encoded encrypted source language code (default: kan_Knda after decryption)")
 
-    @field_validator("prompt")
-    def prompt_must_be_valid(cls, v):
+    @field_validator("prompt", "src_lang")
+    def must_be_valid_base64(cls, v):
         try:
             base64.b64decode(v)
         except Exception:
-            raise ValueError("Prompt must be valid base64-encoded data")
+            raise ValueError("Field must be valid base64-encoded data")
         return v
 
     class Config:
         schema_extra = {
             "example": {
                 "prompt": "base64_encoded_encrypted_prompt",
-                "src_lang": "kan_Knda"
+                "src_lang": "base64_encoded_encrypted_kan_Knda"
             }
         }
 
@@ -145,24 +145,30 @@ class ChatResponse(BaseModel):
 
 class TranslationRequest(BaseModel):
     sentences: List[str] = Field(..., description="List of base64-encoded encrypted sentences")
-    src_lang: str = Field(..., description="Source language code")
-    tgt_lang: str = Field(..., description="Target language code")
-
-    @field_validator("sentences")
-    def sentences_must_be_valid(cls, v):
-        for sentence in v:
+    src_lang: str = Field(..., description="Base64-encoded encrypted source language code")
+    tgt_lang: str = Field(..., description="Base64-encoded encrypted target language code")
+
+    @field_validator("sentences", "src_lang", "tgt_lang")
+    def must_be_valid_base64(cls, v):
+        if isinstance(v, list):
+            for item in v:
+                try:
+                    base64.b64decode(item)
+                except Exception:
+                    raise ValueError("Each sentence must be valid base64-encoded data")
+        else:
             try:
-                base64.b64decode(sentence)
+                base64.b64decode(v)
             except Exception:
-                raise ValueError("Each sentence must be valid base64-encoded data")
+                raise ValueError("Field must be valid base64-encoded data")
         return v
 
     class Config:
         schema_extra = {
             "example": {
                 "sentences": ["base64_encoded_encrypted_hello", "base64_encoded_encrypted_how_are_you"],
-                "src_lang": "en",
-                "tgt_lang": "kan_Knda"
+                "src_lang": "base64_encoded_encrypted_en",
+                "tgt_lang": "base64_encoded_encrypted_kan_Knda"
             }
         }
 
@@ -173,16 +179,16 @@ class TranslationResponse(BaseModel):
         schema_extra = {"example": {"translations": ["ನಮಸ್ಕಾರ", "ನೀವು ಹೇಗಿದ್ದೀರಿ?"]}} 
 
 class VisualQueryRequest(BaseModel):
-    query: str
-    src_lang: str = "kan_Knda"
-    tgt_lang: str = "kan_Knda"
+    query: str = Field(..., description="Base64-encoded encrypted text query")
+    src_lang: str = Field(..., description="Base64-encoded encrypted source language code")
+    tgt_lang: str = Field(..., description="Base64-encoded encrypted target language code")
 
-    @field_validator("query")
-    def query_must_be_valid(cls, v):
+    @field_validator("query", "src_lang", "tgt_lang")
+    def must_be_valid_base64(cls, v):
         try:
             base64.b64decode(v)
         except Exception:
-            raise ValueError("Query must be valid base64-encoded data")
+            raise ValueError("Field must be valid base64-encoded data")
         return v
 
 class VisualQueryResponse(BaseModel):
@@ -276,7 +282,7 @@ async def register_user(
 
 @app.post("/v1/app/register",
           response_model=TokenResponse,
-          summary="Register New App User",
+          summary="Register New App User ",
           description="Create a new user account for the mobile app in the `app_users` table using an encrypted email and device token. Returns an access token and refresh token. Rate limited to 5 requests per minute per IP. Requires X-Session-Key header.",
           tags=["Authentication"],
           responses={
@@ -348,11 +354,11 @@ async def generate_audio(
 @app.post("/v1/chat", 
           response_model=ChatResponse,
           summary="Chat with AI",
-          description="Generate a chat response from an encrypted prompt in the specified language. Rate limited to 100 requests per minute per user. Requires authentication and X-Session-Key header.",
+          description="Generate a chat response from an encrypted prompt and encrypted language code. Rate limited to 100 requests per minute per user. Requires authentication and X-Session-Key header.",
           tags=["Chat"],
           responses={
               200: {"description": "Chat response", "model": ChatResponse},
-              400: {"description": "Invalid prompt or encrypted data"},
+              400: {"description": "Invalid prompt, encrypted data, or language code"},
               401: {"description": "Unauthorized - Token required"},
               429: {"description": "Rate limit exceeded"},
               504: {"description": "Chat service timeout"}
@@ -375,19 +381,27 @@ async def chat(
         logger.error(f"Prompt decryption failed: {str(e)}")
         raise HTTPException(status_code=400, detail="Invalid encrypted prompt")
     
+    # Decrypt the source language
+    try:
+        encrypted_src_lang = base64.b64decode(chat_request.src_lang)
+        decrypted_src_lang = decrypt_data(encrypted_src_lang, session_key).decode("utf-8")
+    except Exception as e:
+        logger.error(f"Source language decryption failed: {str(e)}")
+        raise HTTPException(status_code=400, detail="Invalid encrypted source language")
+    
     if not decrypted_prompt:
         raise HTTPException(status_code=400, detail="Prompt cannot be empty")
     if len(decrypted_prompt) > 1000:
         raise HTTPException(status_code=400, detail="Decrypted prompt cannot exceed 1000 characters")
     
-    logger.info(f"Received prompt: {decrypted_prompt}, src_lang: {chat_request.src_lang}, user_id: {user_id}")
+    logger.info(f"Received prompt: {decrypted_prompt}, src_lang: {decrypted_src_lang}, user_id: {user_id}")
     
     try:
         external_url = "https://slabstech-dhwani-internal-api-server.hf.space/v1/chat"
         payload = {
             "prompt": decrypted_prompt,
-            "src_lang": chat_request.src_lang,
-            "tgt_lang": chat_request.src_lang
+            "src_lang": decrypted_src_lang,
+            "tgt_lang": decrypted_src_lang
         }
         
         response = requests.post(
@@ -431,13 +445,30 @@ async def chat(
 async def process_audio(
     request: Request,
     file: UploadFile = File(..., description="Audio file to process"),
-    language: str = Query(..., enum=["kannada", "hindi", "tamil"], description="Language of the audio"),
-    credentials: HTTPAuthorizationCredentials = Depends(bearer_scheme)
+    language: str = Query(..., description="Base64-encoded encrypted language of the audio (kannada, hindi, tamil after decryption)"),
+    credentials: HTTPAuthorizationCredentials = Depends(bearer_scheme),
+    x_session_key: str = Header(..., alias="X-Session-Key")
 ):
     user_id = await get_current_user(credentials)
+    session_key = base64.b64decode(x_session_key)
+    
+    # Decrypt the language
+    try:
+        encrypted_language = base64.b64decode(language)
+        decrypted_language = decrypt_data(encrypted_language, session_key).decode("utf-8")
+    except Exception as e:
+        logger.error(f"Language decryption failed: {str(e)}")
+        raise HTTPException(status_code=400, detail="Invalid encrypted language")
+    
+    # Validate language
+    allowed_languages = ["kannada", "hindi", "tamil"]
+    if decrypted_language not in allowed_languages:
+        raise HTTPException(status_code=400, detail=f"Language must be one of {allowed_languages}")
+    
     logger.info("Processing audio processing request", extra={
         "endpoint": "/v1/process_audio",
         "filename": file.filename,
+        "language": decrypted_language,
         "client_ip": get_remote_address(request),
         "user_id": user_id
     })
@@ -447,7 +478,7 @@ async def process_audio(
         file_content = await file.read()
         files = {"file": (file.filename, file_content, file.content_type)}
         
-        external_url = f"{settings.external_audio_proc_url}/process_audio/?language={language}"
+        external_url = f"{settings.external_audio_proc_url}/process_audio/?language={decrypted_language}"
         response = requests.post(
             external_url,
             files=files,
@@ -469,30 +500,43 @@ async def process_audio(
 @app.post("/v1/transcribe/", 
           response_model=TranscriptionResponse,
           summary="Transcribe Audio File",
-          description="Transcribe an encrypted audio file into text in the specified language. Requires authentication and X-Session-Key header.",
+          description="Transcribe an encrypted audio file into text in the specified encrypted language. Requires authentication and X-Session-Key header.",
           tags=["Audio"],
           responses={
               200: {"description": "Transcription result", "model": TranscriptionResponse},
-              400: {"description": "Invalid encrypted audio"},
+              400: {"description": "Invalid encrypted audio or language"},
               401: {"description": "Unauthorized - Token required"},
               504: {"description": "Transcription service timeout"}
           })
 async def transcribe_audio(
     file: UploadFile = File(..., description="Encrypted audio file to transcribe"),
-    language: str = Query(..., enum=["kannada", "hindi", "tamil"], description="Language of the audio"),
+    language: str = Query(..., description="Base64-encoded encrypted language of the audio (kannada, hindi, tamil after decryption)"),
     credentials: HTTPAuthorizationCredentials = Depends(bearer_scheme),
     x_session_key: str = Header(..., alias="X-Session-Key")
 ):
     user_id = await get_current_user(credentials)
     session_key = base64.b64decode(x_session_key)
     
+    # Decrypt the language
+    try:
+        encrypted_language = base64.b64decode(language)
+        decrypted_language = decrypt_data(encrypted_language, session_key).decode("utf-8")
+    except Exception as e:
+        logger.error(f"Language decryption failed: {str(e)}")
+        raise HTTPException(status_code=400, detail="Invalid encrypted language")
+    
+    # Validate language
+    allowed_languages = ["kannada", "hindi", "tamil"]
+    if decrypted_language not in allowed_languages:
+        raise HTTPException(status_code=400, detail=f"Language must be one of {allowed_languages}")
+    
     start_time = time()
     try:
         encrypted_content = await file.read()
         file_content = decrypt_data(encrypted_content, session_key)
         files = {"file": (file.filename, file_content, file.content_type)}
         
-        external_url = f"{settings.external_asr_url}/transcribe/?language={language}"
+        external_url = f"{settings.external_asr_url}/transcribe/?language={decrypted_language}"
         response = requests.post(
             external_url,
             files=files,
@@ -555,11 +599,11 @@ async def chat_v2(
 @app.post("/v1/translate", 
           response_model=TranslationResponse,
           summary="Translate Text",
-          description="Translate a list of base64-encoded encrypted sentences from source to target language. Requires authentication and X-Session-Key header.",
+          description="Translate a list of base64-encoded encrypted sentences from an encrypted source to an encrypted target language. Requires authentication and X-Session-Key header.",
           tags=["Translation"],
           responses={
               200: {"description": "Translation result", "model": TranslationResponse},
-              400: {"description": "Invalid encrypted sentences"},
+              400: {"description": "Invalid encrypted sentences or languages"},
               401: {"description": "Unauthorized - Token required"},
               500: {"description": "Translation service error"},
               504: {"description": "Translation service timeout"}
@@ -583,14 +627,30 @@ async def translate(
             logger.error(f"Sentence decryption failed: {str(e)}")
             raise HTTPException(status_code=400, detail="Invalid encrypted sentence")
     
-    logger.info(f"Received translation request: {decrypted_sentences}, src_lang: {request.src_lang}, tgt_lang: {request.tgt_lang}, user_id: {user_id}")
+    # Decrypt source language
+    try:
+        encrypted_src_lang = base64.b64decode(request.src_lang)
+        decrypted_src_lang = decrypt_data(encrypted_src_lang, session_key).decode("utf-8")
+    except Exception as e:
+        logger.error(f"Source language decryption failed: {str(e)}")
+        raise HTTPException(status_code=400, detail="Invalid encrypted source language")
+    
+    # Decrypt target language
+    try:
+        encrypted_tgt_lang = base64.b64decode(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")
+    
+    logger.info(f"Received translation request: {decrypted_sentences}, src_lang: {decrypted_src_lang}, tgt_lang: {decrypted_tgt_lang}, user_id: {user_id}")
     
-    external_url = f"https://slabstech-dhwani-internal-api-server.hf.space/translate?src_lang={request.src_lang}&tgt_lang={request.tgt_lang}"
+    external_url = f"https://slabstech-dhwani-internal-api-server.hf.space/translate?src_lang={decrypted_src_lang}&tgt_lang={decrypted_tgt_lang}"
     
     payload = {
         "sentences": decrypted_sentences,
-        "src_lang": request.src_lang,
-        "tgt_lang": request.tgt_lang
+        "src_lang": decrypted_src_lang,
+        "tgt_lang": decrypted_tgt_lang
     }
     
     try:
@@ -628,11 +688,11 @@ async def translate(
 @app.post("/v1/visual_query", 
           response_model=VisualQueryResponse,
           summary="Visual Query with Image",
-          description="Process a visual query with an encrypted text query and encrypted image. Rate limited to 100 requests per minute per user. Requires authentication and X-Session-Key header.",
+          description="Process a visual query with an encrypted text query, encrypted image, and encrypted language codes. Rate limited to 100 requests per minute per user. Requires authentication and X-Session-Key header.",
           tags=["Chat"],
           responses={
               200: {"description": "Query response", "model": VisualQueryResponse},
-              400: {"description": "Invalid query or encrypted data"},
+              400: {"description": "Invalid query, encrypted data, or language codes"},
               401: {"description": "Unauthorized - Token required"},
               429: {"description": "Rate limit exceeded"},
               504: {"description": "Visual query service timeout"}
@@ -642,8 +702,8 @@ async def visual_query(
     request: Request,
     query: str = Form(..., description="Base64-encoded encrypted text query"),
     file: UploadFile = File(..., description="Encrypted image file to analyze"),
-    src_lang: str = Query(default="kan_Knda", description="Source language code"),
-    tgt_lang: str = Query(default="kan_Knda", description="Target language code"),
+    src_lang: str = Form(..., description="Base64-encoded encrypted source language code"),
+    tgt_lang: str = Form(..., description="Base64-encoded encrypted target language code"),
     credentials: HTTPAuthorizationCredentials = Depends(bearer_scheme),
     x_session_key: str = Header(..., alias="X-Session-Key")
 ):
@@ -658,6 +718,22 @@ async def visual_query(
         logger.error(f"Query decryption failed: {str(e)}")
         raise HTTPException(status_code=400, detail="Invalid encrypted query")
     
+    # Decrypt source language
+    try:
+        encrypted_src_lang = base64.b64decode(src_lang)
+        decrypted_src_lang = decrypt_data(encrypted_src_lang, session_key).decode("utf-8")
+    except Exception as e:
+        logger.error(f"Source language decryption failed: {str(e)}")
+        raise HTTPException(status_code=400, detail="Invalid encrypted source language")
+    
+    # Decrypt target language
+    try:
+        encrypted_tgt_lang = base64.b64decode(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_query.strip():
         raise HTTPException(status_code=400, detail="Query cannot be empty")
     if len(decrypted_query) > 1000:
@@ -677,11 +753,11 @@ async def visual_query(
         "file_name": file.filename,
         "client_ip": get_remote_address(request),
         "user_id": user_id,
-        "src_lang": src_lang,
-        "tgt_lang": tgt_lang
+        "src_lang": decrypted_src_lang,
+        "tgt_lang": decrypted_tgt_lang
     })
     
-    external_url = f"https://slabstech-dhwani-internal-api-server.hf.space/v1/visual_query/?src_lang={src_lang}&tgt_lang={tgt_lang}"
+    external_url = f"https://slabstech-dhwani-internal-api-server.hf.space/v1/visual_query/?src_lang={decrypted_src_lang}&tgt_lang={decrypted_tgt_lang}"
     
     try:
         files = {"file": (file.filename, decrypted_content, file.content_type)}
@@ -725,11 +801,11 @@ class SupportedLanguage(str, Enum):
 
 @app.post("/v1/speech_to_speech",
           summary="Speech-to-Speech Conversion",
-          description="Convert input encrypted speech to processed speech by calling an external speech-to-speech API. Rate limited to 5 requests per minute per user. Requires authentication and X-Session-Key header.",
+          description="Convert input encrypted speech to processed speech in the specified encrypted language by calling an external speech-to-speech API. 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 or encrypted audio"},
+              400: {"description": "Invalid input, encrypted audio, or language"},
               401: {"description": "Unauthorized - Token required"},
               429: {"description": "Rate limit exceeded"},
               504: {"description": "External API timeout"},
@@ -739,17 +815,30 @@ class SupportedLanguage(str, Enum):
 async def speech_to_speech(
     request: Request,
     file: UploadFile = File(..., description="Encrypted audio file to process"),
-    language: SupportedLanguage = Query(..., description="Language of the audio (kannada, hindi, tamil)"),
+    language: str = Query(..., description="Base64-encoded encrypted language of the audio (kannada, hindi, tamil after decryption)"),
     credentials: HTTPAuthorizationCredentials = Depends(bearer_scheme),
     x_session_key: str = Header(..., alias="X-Session-Key")
 ) -> StreamingResponse:
     user_id = await get_current_user(credentials)
     session_key = base64.b64decode(x_session_key)
     
+    # Decrypt the language
+    try:
+        encrypted_language = base64.b64decode(language)
+        decrypted_language = decrypt_data(encrypted_language, session_key).decode("utf-8")
+    except Exception as e:
+        logger.error(f"Language decryption failed: {str(e)}")
+        raise HTTPException(status_code=400, detail="Invalid encrypted language")
+    
+    # Validate language
+    allowed_languages = [lang.value for lang in SupportedLanguage]
+    if decrypted_language not in allowed_languages:
+        raise HTTPException(status_code=400, detail=f"Language must be one of {allowed_languages}")
+    
     logger.info("Processing speech-to-speech request", extra={
         "endpoint": "/v1/speech_to_speech",
         "audio_filename": file.filename,
-        "language": language,
+        "language": decrypted_language,
         "client_ip": get_remote_address(request),
         "user_id": user_id
     })
@@ -758,7 +847,7 @@ async def speech_to_speech(
         encrypted_content = await file.read()
         file_content = decrypt_data(encrypted_content, session_key)
         files = {"file": (file.filename, file_content, file.content_type)}
-        external_url = f"https://slabstech-dhwani-internal-api-server.hf.space/v1/speech_to_speech?language={language}"
+        external_url = f"https://slabstech-dhwani-internal-api-server.hf.space/v1/speech_to_speech?language={decrypted_language}"
 
         response = requests.post(
             external_url,