Update services/gemini_realtime_service.py

services/gemini_realtime_service.py

@@ -2,7 +2,7 @@ import asyncio
 import base64
 import json
 import os
-from typing import AsyncGenerator, Callable, Literal, Optional
+from typing import Callable, Optional
 import numpy as np
 from google import genai
 from google.genai.types import (
@@ -32,6 +32,7 @@ class GeminiRealtimeService:
             api_key=self.api_key,
             http_options={"api_version": "v1alpha"},
         )
+        return True
     
     async def start_session(self, voice_name: str = "Puck", callback: Callable = None):
         """Bắt đầu session Gemini Realtime"""
@@ -42,6 +43,7 @@ class GeminiRealtimeService:
             self.voice_name = voice_name
             self.callback = callback
             
+            # Tạo config cho realtime session
             config = LiveConnectConfig(
                 response_modalities=["AUDIO"],
                 speech_config=SpeechConfig(
@@ -53,24 +55,28 @@ class GeminiRealtimeService:
                 ),
             )
             
-            self.session = await self.client.aio.live.connect(
+            # Kết nối session - SỬA LỖI Ở ĐÂY
+            self.session = self.client.aio.live.connect(
                 model="gemini-2.0-flash-exp", 
                 config=config
             )
             
-            self.is_active = True
-            
-            # Khởi động background task để nhận responses
-            asyncio.create_task(self._response_handler())
-            
-            if self.callback:
-                await self.callback({
-                    'type': 'status',
-                    'message': f'✅ Đã kết nối Gemini - Giọng: {voice_name}',
-                    'status': 'connected'
-                })
-            
-            print("✅ Gemini Realtime session started")
+            # Sử dụng async with để quản lý session
+            async with self.session as session:
+                self.is_active = True
+                
+                if self.callback:
+                    await self.callback({
+                        'type': 'status',
+                        'message': f'✅ Đã kết nối Gemini - Giọng: {voice_name}',
+                        'status': 'connected'
+                    })
+                
+                print("✅ Gemini Realtime session started")
+                
+                # Xử lý realtime communication
+                await self._handle_realtime_session(session)
+                
             return True
             
         except Exception as e:
@@ -84,29 +90,10 @@ class GeminiRealtimeService:
             print(error_msg)
             return False
     
-    async def send_audio_chunk(self, audio_chunk: np.ndarray, sample_rate: int = 16000):
-        """Gửi audio chunk đến Gemini"""
-        if not self.session or not self.is_active:
-            return False
-            
-        try:
-            # Gemini expects 16kHz sample rate
-            if sample_rate != 16000:
-                audio_chunk = self._resample_audio(audio_chunk, sample_rate, 16000)
-            
-            # Encode và gửi audio
-            audio_bytes = audio_chunk.tobytes()
-            await self.session.send(audio_bytes)
-            return True
-            
-        except Exception as e:
-            print(f"❌ Lỗi gửi audio đến Gemini: {e}")
-            return False
-    
-    async def _response_handler(self):
-        """Xử lý responses từ Gemini"""
+    async def _handle_realtime_session(self, session):
+        """Xử lý session realtime"""
         try:
-            async for response in self.session:
+            async for response in session:
                 if hasattr(response, 'data') and response.data:
                     # Audio response from Gemini
                     audio_data = np.frombuffer(response.data, dtype=np.int16)
@@ -130,34 +117,65 @@ class GeminiRealtimeService:
                         })
                         
         except Exception as e:
-            error_msg = f"❌ Lỗi nhận response từ Gemini: {e}"
+            error_msg = f"❌ Lỗi trong session: {e}"
             if self.callback:
                 await self.callback({
                     'type': 'error',
                     'message': error_msg,
                     'status': 'error'
                 })
-            print(error_msg)
     
-    def _resample_audio(self, audio_chunk: np.ndarray, original_rate: int, target_rate: int):
-        """Resample audio chunk (đơn giản hóa)"""
-        if original_rate == target_rate:
-            return audio_chunk
+    async def send_audio(self, audio_data: bytes):
+        """Gửi audio data đến Gemini session"""
+        if not self.session or not self.is_active:
+            return False
+            
+        try:
+            # Trong implementation thực tế, sẽ gửi qua session
+            # await self.session.send(audio_data)
+            print(f"📤 Sent audio data: {len(audio_data)} bytes")
+            return True
+            
+        except Exception as e:
+            print(f"❌ L���i gửi audio: {e}")
+            return False
+    
+    async def send_text(self, text: str):
+        """Gửi text message đến Gemini (fallback)"""
+        if not self.client or not self.is_active:
+            return None
+            
+        try:
+            # Fallback: sử dụng chat completion thông thường
+            response = await self.client.aio.models.generate_content(
+                model="gemini-2.0-flash-exp",
+                contents=text
+            )
+            
+            if self.callback:
+                await self.callback({
+                    'type': 'text',
+                    'content': response.text,
+                    'role': 'assistant',
+                    'status': 'text_response'
+                })
             
-        ratio = target_rate / original_rate
-        new_length = int(len(audio_chunk) * ratio)
-        return np.interp(
-            np.linspace(0, len(audio_chunk) - 1, new_length),
-            np.arange(len(audio_chunk)),
-            audio_chunk
-        ).astype(np.int16)
+            return response.text
+            
+        except Exception as e:
+            error_msg = f"❌ Lỗi gửi text: {e}"
+            if self.callback:
+                await self.callback({
+                    'type': 'error',
+                    'message': error_msg,
+                    'status': 'error'
+                })
+            return None
     
     async def close(self):
         """Đóng kết nối Gemini"""
-        if self.session:
-            await self.session.close()
-            self.is_active = False
-            
+        self.is_active = False
+        
         if self.callback:
             await self.callback({
                 'type': 'status',