Update app.py

app.py

@@ -7,7 +7,7 @@ import google.generativeai as genai
 from google.api_core.exceptions import ResourceExhausted
 
 # -----------------------
-# Configuration / secrets
+# Config / Secrets
 # -----------------------
 GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
 ELEVENLABS_API_KEY = os.environ.get("ELEVENLABS_API_KEY")
@@ -17,9 +17,8 @@ AUDIO_TMP_DIR = "/tmp"
 if not GEMINI_API_KEY:
     raise RuntimeError("Missing GEMINI_API_KEY in environment. Set it in HF Space Secrets.")
 
-# Configure Gemini SDK
+# Configure Gemini
 genai.configure(api_key=GEMINI_API_KEY)
-# single model instance
 gemini_model = genai.GenerativeModel("gemini-2.5-flash")
 
 # -----------------------
@@ -28,7 +27,7 @@ gemini_model = genai.GenerativeModel("gemini-2.5-flash")
 class SimpleMemory:
     def __init__(self, max_messages=20):
         self.max_messages = max_messages
-        self.history = []  # tuples (role, text)
+        self.history = []  # list of tuples (role, text) with role in {"user","bot"}
 
     def add(self, role, text):
         self.history.append((role, text))
@@ -36,49 +35,85 @@ class SimpleMemory:
             self.history = self.history[-self.max_messages :]
 
     def as_prompt_text(self):
-        # produce compact prompt history
         lines = []
-        for role, text in self.history:
+        for role, txt in self.history:
             if role == "user":
-                lines.append(f"User: {text}")
+                lines.append(f"User: {txt}")
             else:
-                lines.append(f"Chatbot: {text}")
+                lines.append(f"Chatbot: {txt}")
         return "\n".join(lines)
 
 memory = SimpleMemory(max_messages=20)
 
 # -----------------------
-# Gemini text generation (safe)
+# Prompt template
 # -----------------------
 PROMPT_TEMPLATE = """You are a helpful assistant.
 {chat_history}
 User: {user_message}
 Chatbot:"""
 
+# -----------------------
+# Robust Gemini generator (tries multiple message formats)
+# Returns: (text_or_None, error_message_or_None)
+# -----------------------
 def generate_text_with_gemini(user_message):
     chat_history_text = memory.as_prompt_text()
-    prompt = PROMPT_TEMPLATE.format(chat_history=chat_history_text, user_message=user_message)
+    full_prompt = PROMPT_TEMPLATE.format(chat_history=chat_history_text, user_message=user_message)
 
+    # 1) Try the simplest call (raw prompt)
     try:
-        response = gemini_model.generate_content(prompt)
-        text = response.text if hasattr(response, "text") else str(response)
+        resp = gemini_model.generate_content(full_prompt)
+        text = getattr(resp, "text", None)
+        if not text:
+            text = str(resp)
         return text, None
     except ResourceExhausted as e:
-        # quota exceeded — return friendly message
-        print("Gemini quota exhausted:", e)
+        print("Gemini quota exhausted (raw prompt):", e)
         return None, "Gemini quota exceeded. Please try again later."
-    except Exception as e:
-        print("Gemini error:", e)
-        return None, f"Gemini error: {str(e)}"
+    except Exception as e1:
+        print("generate_content(raw) failed, will retry with messages format:", repr(e1))
+
+    # 2) Try messages with content as plain string
+    try:
+        messages = [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": full_prompt}
+        ]
+        resp = gemini_model.generate_content(messages=messages)
+        text = getattr(resp, "text", None)
+        if not text:
+            text = str(resp)
+        return text, None
+    except ResourceExhausted as e:
+        print("Gemini quota exhausted (messages):", e)
+        return None, "Gemini quota exceeded. Please try again later."
+    except Exception as e2:
+        print("generate_content(messages) failed, will retry with typed content:", repr(e2))
+
+    # 3) Try messages where content is a list of typed chunks
+    try:
+        messages2 = [
+            {"role": "system", "content": [{"type": "text", "text": "You are a helpful assistant."}]},
+            {"role": "user", "content": [{"type": "text", "text": full_prompt}]}
+        ]
+        resp = gemini_model.generate_content(messages=messages2)
+        text = getattr(resp, "text", None)
+        if not text:
+            text = str(resp)
+        return text, None
+    except ResourceExhausted as e:
+        print("Gemini quota exhausted (messages2):", e)
+        return None, "Gemini quota exceeded. Please try again later."
+    except Exception as efinal:
+        print("Gemini generate_content all attempts failed:", repr(efinal))
+        return None, f"Gemini error: {repr(efinal)}"
 
 # -----------------------
-# ElevenLabs HTTP fallback (robust)
+# ElevenLabs HTTP TTS (fallback, robust)
+# Returns: (output_path_or_empty, error_or_empty)
 # -----------------------
 def generate_audio_elevenlabs_http(text):
-    """
-    Returns (output_path, error_message). On success: output_path path string, error_message empty.
-    On failure: output_path '', error_message string.
-    """
     if not ELEVENLABS_API_KEY:
         return "", "ELEVENLABS_API_KEY not configured."
 
@@ -97,13 +132,12 @@ def generate_audio_elevenlabs_http(text):
     try:
         resp = requests.post(url, json=payload, headers=headers, timeout=30)
     except Exception as e:
-        err = f"HTTP request to ElevenLabs failed: {e}"
+        err = f"ElevenLabs HTTP request failed: {e}"
         print(err)
         return "", err
 
     if resp.status_code == 200:
         try:
-            # save audio bytes to temp file
             filename = f"audio_{int(time.time()*1000)}_{abs(hash(text))%100000}.mp3"
             path = os.path.join(AUDIO_TMP_DIR, filename)
             with open(path, "wb") as f:
@@ -114,7 +148,6 @@ def generate_audio_elevenlabs_http(text):
             print(err)
             return "", err
     else:
-        # return response body if available
         try:
             body = resp.json()
         except Exception:
@@ -124,74 +157,70 @@ def generate_audio_elevenlabs_http(text):
         return "", err
 
 # -----------------------
-# Main combined workflow
+# Combined workflow
 # -----------------------
 def process_user_message(user_message):
-    """
-    Returns tuple: (chat_history_list, audio_path_or_empty, error_message_or_empty)
-    chat_history_list is a list of (speaker, message) for the UI chat component.
-    """
-    # 1) Get text from Gemini with error handling
+    # 1) Generate text (robust)
     text, gen_err = generate_text_with_gemini(user_message)
     if gen_err:
-        # don't crash — show friendly message and no audio
+        # safe fallback: store user and friendly message
         memory.add("user", user_message)
-        fallback_text = "Sorry — the assistant is temporarily unavailable: " + gen_err
-        memory.add("bot", fallback_text)
-        # build chat list for UI
-        chat_list = [(role, msg) for role, msg in memory.history]
-        return chat_list, "", gen_err
+        fallback = "Sorry — the assistant is temporarily unavailable: " + gen_err
+        memory.add("bot", fallback)
+        history_pairs = convert_memory_to_pairs(memory.history)
+        return history_pairs, "", gen_err
 
-    # 2) Update memory
+    # 2) update memory
     memory.add("user", user_message)
     memory.add("bot", text)
 
-    # 3) Try to generate audio (HTTP fallback)
+    # 3) try audio (HTTP fallback)
     audio_path, audio_err = generate_audio_elevenlabs_http(text)
     if audio_err:
         print("Audio generation error:", audio_err)
-    # Return history and audio (audio path may be empty)
-    chat_list = [(role, msg) for role, msg in memory.history]
-    return chat_list, audio_path or "", audio_err or ""
+
+    history_pairs = convert_memory_to_pairs(memory.history)
+    return history_pairs, audio_path or "", audio_err or ""
+
+def convert_memory_to_pairs(history):
+    """
+    Convert memory list of tuples into chat pairs for gr.Chatbot.
+    memory.history is [(role, text), ...] where roles alternate.
+    Returns list of (user_text, bot_text) pairs.
+    """
+    pairs = []
+    temp_user = None
+    for role, msg in history:
+        if role == "user":
+            temp_user = msg
+        else:  # bot
+            pairs.append((temp_user or "", msg))
+            temp_user = None
+    return pairs
 
 # -----------------------
-# Gradio UI (Blocks)
+# Gradio UI
 # -----------------------
 with gr.Blocks() as demo:
     gr.Markdown("## 🤖 Gemini + ElevenLabs Chatbot (Text + Audio replies)")
-    chatbot = gr.Chatbot(elem_id="chatbot")
+    chatbot = gr.Chatbot()
     with gr.Row():
         txt = gr.Textbox(show_label=False, placeholder="Type your message and press Enter")
         send_btn = gr.Button("Send")
-
     audio_player = gr.Audio(label="Last reply audio (if available)", visible=False)
 
-    # submit action
     def submit_message(message):
-        # process and return chat content and audio
-        history, audio_path, audio_err = process_user_message(message)
-        # format chat history for gr.Chatbot: list of [user, bot] pairs for display
-        # our memory stores alternating user/bot entries; convert to pairs
-        pairs = []
-        temp_user = None
-        for role, msg in history:
-            if role == "user":
-                temp_user = msg
-            else:
-                pairs.append((temp_user or "", msg))
-                temp_user = None
-
-        # show audio if available
+        # Run the combined workflow
+        pairs, audio_path, err = process_user_message(message)
+        # The chat UI expects list of pairs (user, bot)
         if audio_path:
             return pairs, gr.update(value=audio_path, visible=True)
         else:
             return pairs, gr.update(value=None, visible=False)
 
-    # wire button and textbox
     send_btn.click(fn=submit_message, inputs=[txt], outputs=[chatbot, audio_player])
     txt.submit(fn=submit_message, inputs=[txt], outputs=[chatbot, audio_player])
 
-# Launch
+# Launch app
 if __name__ == "__main__":
-    # Do not enable share=True unless you want a public link
     demo.launch(debug=True)