Update app.py

app.py

@@ -5,18 +5,18 @@ from google import genai
 
 app = Quart(__name__)
 
-# Force v1beta version (Required for the 'live' preview models)
+# Force v1beta version (Required for Native Audio and Live features)
 client = genai.Client(http_options={'api_version': 'v1beta'})
 
-# The exact key from your available_models list; models/gemini-2.5-flash-native-audio-preview-12-2025
+# Using the Native Audio preview model you identified
 MODEL = "models/gemini-2.5-flash-native-audio-preview-12-2025" 
 
 VOICE_MODES = {
-    'Zephyr': 'Zephyr', # Default / Balanced
-    'Puck': 'Puck',     # Energetic / Bright
-    'Charon': 'Charon', # Deep / Calm
-    'Kore': 'Kore',     # Soft / Warm
-    'Fenrir': 'Fenrir'  # Formal / Sharp
+    'Zephyr': 'Zephyr',
+    'Puck': 'Puck',
+    'Charon': 'Charon',
+    'Kore': 'Kore',
+    'Fenrir': 'Fenrir'
 }
 
 @app.route('/')
@@ -24,25 +24,12 @@ async def index():
     return {
         "status": "online",
         "service": "ASH-BAND Live Neural Link",
-        "endpoint": "/stream",
-        "supported_voices": list(VOICE_MODES.keys())
+        "model": MODEL,
+        "endpoint": "/stream"
     }
 
-@app.route('/models')
-async def list_models():
-    """Use this to see exactly which models your key has access to if it fails."""
-    try:
-        models = client.models.list()
-        return {"available_models": [m.name for m in models]}
-    except Exception as e:
-        return {"error": str(e)}
-
 @app.websocket('/stream')
 async def ws_stream():
-    """
-    WebSocket endpoint for the Termux client.
-    Connect via: wss://<hf-space-url>/stream?voice=Zephyr
-    """
     requested_voice = websocket.args.get("voice", "Zephyr")
     voice_name = VOICE_MODES.get(requested_voice, "Zephyr")
 
@@ -56,8 +43,7 @@ async def ws_stream():
         "tools": [{"google_search": {}}],
         "system_instruction": (
             "You are ASH-BAND, a high-fidelity AI wearable companion. "
-            "Speak in a professional, concise, and helpful tone. "
-            "Keep responses brief to minimize latency. Your responses are spoken aloud."
+            "Speak concisely and professionally. Your responses are spoken aloud."
         )
     }
 
@@ -72,45 +58,34 @@ async def ws_stream():
                     while True:
                         data = await websocket.receive()
                         if isinstance(data, bytes):
+                            # Handle microphone audio
                             await session.send(
                                 input={"data": data, "mime_type": "audio/pcm;rate=16000"}
                             )
-                except asyncio.CancelledError:
-                    pass
+                        elif isinstance(data, str):
+                            # Handle 'echo' text commands from Termux
+                            await session.send(input=data)
                 except Exception as e:
-                    print(f"Error reading from client: {e}")
+                    print(f"Client -> Gemini Error: {e}")
 
             async def gemini_to_client():
                 try:
                     async for message in session.receive():
-                        server_content = message.server_content
-                        if server_content:
-                            if server_content.interrupted:
-                                print("AI Interrupted.")
-                                
-                            model_turn = server_content.model_turn
-                            if model_turn:
-                                for part in model_turn.parts:
-                                    if part.inline_data and part.inline_data.data:
-                                        await websocket.send(part.inline_data.data)
-                except asyncio.CancelledError:
-                    pass
+                        if message.server_content and message.server_content.model_turn:
+                            for part in message.server_content.model_turn.parts:
+                                if part.inline_data and part.inline_data.data:
+                                    # Send back raw 24kHz PCM audio
+                                    await websocket.send(part.inline_data.data)
                 except Exception as e:
-                    print(f"Error receiving from Gemini: {e}")
+                    print(f"Gemini -> Client Error: {e}")
 
-            task1 = asyncio.create_task(client_to_gemini())
-            task2 = asyncio.create_task(gemini_to_client())
-            
-            await asyncio.wait(
-                [task1, task2],
-                return_when=asyncio.FIRST_COMPLETED,
-            )
-            
-            task1.cancel()
-            task2.cancel()
+            # Run both tasks and wait for them to finish or error out
+            await asyncio.gather(client_to_gemini(), gemini_to_client())
                 
     except Exception as e:
         print(f"Connection failed: {e}")
+    finally:
+        print("Session closed.")
 
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860)