react-native-agentic-ai 0.4.6 → 0.5.1

package/src/services/VoiceService.ts

@@ -1,15 +1,26 @@
 /**
- * VoiceService — WebSocket connection to Gemini Live API.
+ * VoiceService — @google/genai SDK Live API connection.
+ *
+ * Uses the official `ai.live.connect()` method instead of raw WebSocket.
+ * This fixes function calling reliability: the SDK handles protocol details
+ * (binary framing, message transforms, model name prefixes) that our
+ * previous raw WebSocket implementation missed.
  *
  * Handles bidirectional audio streaming between the app and Gemini:
  * - Sends PCM 16kHz 16-bit audio chunks (mic input)
  * - Receives PCM 24kHz 16-bit audio chunks (AI responses)
  * - Receives function calls (tap, navigate, etc.) for agentic actions
- * - Sends screen context (DOM text + optional screenshot) for live mode
- *
- * Protocol: wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent
+ * - Sends screen context (DOM text) for live mode
  */
 
+// Platform-specific import: Metro can't resolve '@google/genai/web' sub-path
+// export, so we use the full path to the web bundle. This is what the SDK
+// recommends ('use a platform specific import') — RN's WebSocket API is
+// browser-compatible so the web bundle works correctly.
+// @ts-ignore — TS can't find declarations for the deep path
+import { GoogleGenAI, Modality } from '@google/genai/dist/web/index.mjs';
+// @ts-ignore
+import type { Session } from '@google/genai/dist/web/index.mjs';
 import { logger } from '../utils/logger';
 import type { ToolDefinition } from '../core/types';
 
@@ -34,29 +45,26 @@ export interface VoiceServiceCallbacks {
   onError?: (error: string) => void;
   /** Called when AI turn is complete (all audio sent) */
   onTurnComplete?: () => void;
+  /** Called when SDK setup is complete — safe to send screen context */
+  onSetupComplete?: () => void;
 }
 
 export type VoiceStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
 
 // ─── Constants ─────────────────────────────────────────────────
 
-const WS_HOST = 'generativelanguage.googleapis.com';
-const WS_PATH = '/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent';
-// Use -09-2025: Google's own cookbook uses this model for Live API tool use.
-// The -12-2025 model had server-side regressions with function calling
-// and was deprecated March 19, 2026. The -09-2025 version has
-// "improved function calling and better handling of speech cut-offs."
-const DEFAULT_MODEL = 'gemini-2.5-flash-native-audio-preview-09-2025';
+const DEFAULT_MODEL = 'gemini-2.5-flash-native-audio-preview-12-2025';
 const DEFAULT_INPUT_SAMPLE_RATE = 16000;
 
 // ─── Service ───────────────────────────────────────────────────
 
 export class VoiceService {
-  private ws: WebSocket | null = null;
+  private session: Session | null = null;
   private config: VoiceServiceConfig;
   private callbacks: VoiceServiceCallbacks = {};
-  private setupComplete = false;
+  public lastCallbacks: VoiceServiceCallbacks | null = null;
   private _status: VoiceStatus = 'disconnected';
+  public intentionalDisconnect = false;
 
   constructor(config: VoiceServiceConfig) {
     this.config = config;
@@ -64,55 +72,115 @@ export class VoiceService {
 
   // ─── Connection ────────────────────────────────────────────
 
-  connect(callbacks: VoiceServiceCallbacks): void {
-    if (this.ws?.readyState === WebSocket.OPEN) {
+  /**
+   * Connect to Gemini Live API via the official SDK.
+   * Now async because `ai.live.connect()` returns a Promise.
+   */
+  async connect(callbacks: VoiceServiceCallbacks): Promise<void> {
+    if (this.session) {
       logger.info('VoiceService', 'Already connected');
       return;
     }
 
     this.callbacks = callbacks;
+    this.lastCallbacks = callbacks;
     this.setStatus('connecting');
+    this.intentionalDisconnect = false;
 
     const model = this.config.model || DEFAULT_MODEL;
-    const url = `wss://${WS_HOST}${WS_PATH}?key=${this.config.apiKey}`;
+    logger.info('VoiceService', `Connecting via SDK (model: ${model})`);
 
-    logger.info('VoiceService', `Connecting to Gemini Live API (model: ${model})`);
-    this.ws = new WebSocket(url);
+    try {
+      const ai = new GoogleGenAI({ apiKey: this.config.apiKey });
 
-    this.ws.onopen = () => {
-      logger.info('VoiceService', 'WebSocket connected, sending setup...');
-      this.sendSetup();
-    };
+      const toolDeclarations = this.buildToolDeclarations();
 
-    this.ws.onclose = (event) => {
-      logger.info('VoiceService', `WebSocket closed: ${event.code} ${event.reason}`);
-      this.setStatus('disconnected');
-      this.setupComplete = false;
-    };
+      // Build SDK config matching the official docs pattern
+      const sdkConfig: Record<string, any> = {
+        responseModalities: [Modality.AUDIO],
+      };
 
-    this.ws.onerror = (error: any) => {
-      logger.error('VoiceService', `WebSocket error: ${error.message || 'Unknown'}`);
-      this.setStatus('error');
-      this.callbacks.onError?.(error.message || 'WebSocket connection error');
-    };
+      // Enable transcription for debugging and UX
+      sdkConfig.inputAudioTranscription = {};
+      sdkConfig.outputAudioTranscription = {};
+      logger.info('VoiceService', 'Transcription enabled');
+
+      if (this.config.systemPrompt) {
+        sdkConfig.systemInstruction = {
+          parts: [{ text: this.config.systemPrompt }],
+        };
+      }
 
-    this.ws.onmessage = (event) => {
-      this.handleMessage(event);
-    };
+      if (toolDeclarations.length > 0) {
+        sdkConfig.tools = [{ functionDeclarations: toolDeclarations }];
+      }
+
+      // FULL CONFIG DUMP — see exactly what we send to SDK
+      const configDump = JSON.stringify({
+        ...sdkConfig,
+        systemInstruction: sdkConfig.systemInstruction ? '(present)' : '(none)',
+        tools: sdkConfig.tools ? `${toolDeclarations.length} declarations` : '(none)',
+      });
+      logger.info('VoiceService', `📋 SDK config: ${configDump}`);
+      logger.info('VoiceService', `📋 Tool names: ${toolDeclarations.map((t: any) => t.name).join(', ')}`);
+
+      const session = await ai.live.connect({
+        model: model,
+        config: sdkConfig,
+        callbacks: {
+          onopen: () => {
+            logger.info('VoiceService', '✅ SDK session connected');
+            this.setStatus('connected');
+          },
+          onmessage: (message: any) => {
+            this.handleSDKMessage(message);
+          },
+          onerror: (error: any) => {
+            const errDetail = error
+              ? JSON.stringify(error, Object.getOwnPropertyNames(error)).substring(0, 500)
+              : 'null';
+            logger.error('VoiceService', `SDK error: ${errDetail}`);
+            this.setStatus('error');
+            this.callbacks.onError?.(error?.message || 'SDK connection error');
+          },
+          onclose: (event: any) => {
+            const closeDetail = event
+              ? JSON.stringify(event, Object.getOwnPropertyNames(event)).substring(0, 500)
+              : 'null';
+            if (this.intentionalDisconnect) {
+              logger.info('VoiceService', `SDK session closed (intentional)`);
+            } else {
+              logger.error('VoiceService', `SDK session closed UNEXPECTEDLY — code: ${event?.code}, reason: ${event?.reason}, detail: ${closeDetail}`);
+              this.callbacks.onError?.(`Connection lost (code: ${event?.code || 'unknown'})`);
+            }
+            this.session = null;
+            this.setStatus('disconnected');
+          },
+        },
+      });
+
+      this.session = session;
+      logger.info('VoiceService', 'SDK session established');
+
+    } catch (error: any) {
+      logger.error('VoiceService', `Connection failed: ${error.message}`);
+      this.setStatus('error');
+      this.callbacks.onError?.(error.message || 'Failed to connect');
+    }
   }
 
   disconnect(): void {
-    if (this.ws) {
-      logger.info('VoiceService', 'Disconnecting...');
-      this.ws.close();
-      this.ws = null;
-      this.setupComplete = false;
+    if (this.session) {
+      logger.info('VoiceService', 'Disconnecting (intentional)...');
+      this.intentionalDisconnect = true;
+      this.session.close();
+      this.session = null;
       this.setStatus('disconnected');
     }
   }
 
   get isConnected(): boolean {
-    return this.ws?.readyState === WebSocket.OPEN && this.setupComplete;
+    return this.session !== null && this._status === 'connected';
   }
 
   get currentStatus(): VoiceStatus {
@@ -121,311 +189,240 @@ export class VoiceService {
 
   // ─── Send Audio ────────────────────────────────────────────
 
-  /** Send PCM audio chunk (base64 encoded) to Gemini */
+  /** Send PCM audio chunk (base64 encoded) via SDK's sendRealtimeInput */
   private sendCount = 0;
   sendAudio(base64Audio: string): void {
     this.sendCount++;
-    if (!this.isConnected) {
-      logger.warn('VoiceService', `sendAudio #${this.sendCount} DROPPED — not connected (ws=${this.ws?.readyState}, setup=${this.setupComplete})`);
+    if (!this.isConnected || !this.session) {
+      if (this.sendCount % 20 === 0) {
+        logger.warn('VoiceService', `sendAudio #${this.sendCount} DROPPED — not connected`);
+      }
       return;
     }
 
-    const message = {
-      realtimeInput: {
-        audio: {
-          mimeType: `audio/pcm;rate=${this.config.inputSampleRate || DEFAULT_INPUT_SAMPLE_RATE}`,
-          data: base64Audio,
-        },
-      },
-    };
+    const mimeType = `audio/pcm;rate=${this.config.inputSampleRate || DEFAULT_INPUT_SAMPLE_RATE}`;
+
+    // DEBUG: log every send call
+    if (this.sendCount <= 5 || this.sendCount % 10 === 0) {
+      logger.info('VoiceService', `📡 sendAudio #${this.sendCount}: len=${base64Audio.length}, mime=${mimeType}, preview=${base64Audio.substring(0, 30)}...`);
+    }
 
-    logger.info('VoiceService', `📤 #${this.sendCount} sending ${base64Audio.length} chars (ws=${this.ws?.readyState})`);
-    this.ws!.send(JSON.stringify(message));
+    try {
+      this.session.sendRealtimeInput({
+        audio: { data: base64Audio, mimeType },
+      });
+      // Log every 50th successful send to confirm data is reaching WebSocket
+      if (this.sendCount % 50 === 0) {
+        logger.info('VoiceService', `✅ sendAudio #${this.sendCount} OK — session.isOpen=${!!this.session}`);
+      }
+    } catch (error: any) {
+      logger.error('VoiceService', `❌ sendAudio EXCEPTION: ${error.message}\n${error.stack?.substring(0, 300)}`);
+      this.session = null;
+      this.setStatus('disconnected');
+    }
   }
 
   // ─── Send Text ─────────────────────────────────────────────
 
-  /** Send text message via realtimeInput (same channel as audio) */
+  /** Send text message via SDK's sendClientContent */
   sendText(text: string): void {
-    if (!this.isConnected) return;
-
-    const message = {
-      realtimeInput: { text },
-    };
+    if (!this.isConnected || !this.session) return;
 
-    this.ws!.send(JSON.stringify(message));
+    logger.info('VoiceService', `🗣️ USER (text): "${text}"`);
+    try {
+      this.session.sendClientContent({
+        turns: [{ role: 'user', parts: [{ text }] }],
+        turnComplete: true,
+      });
+    } catch (error: any) {
+      logger.error('VoiceService', `sendText failed: ${error.message}`);
+    }
   }
 
-  /** Send DOM tree as passive context during live conversation.
-   *
-   * Uses `clientContent` with `turnComplete: false` to inject context
-   * WITHOUT triggering a model response. This is the "incremental content
-   * updates" pattern from the Gemini docs for establishing session context.
-   *
-   * Called once at connect + after each tool call (not on a timer).
-   * Screenshots are handled separately via the capture_screenshot tool.
+  /**
+   * Send DOM tree as passive context during live conversation.
+   * Uses turnComplete: false — the model receives context without responding.
    */
   sendScreenContext(domText: string): void {
-    if (!this.isConnected) return;
+    if (!this.isConnected || !this.session) return;
 
-    const message = {
-      clientContent: {
+    try {
+      this.session.sendClientContent({
         turns: [{ role: 'user', parts: [{ text: domText }] }],
-        turnComplete: false, // Passive context — don't trigger a response
-      },
-    };
-
-    logger.debug('VoiceService', `📤 Screen context sent (${domText.length} chars)`);
-    logger.debug('VoiceService', `📤 Raw Screen Context Payload: ${JSON.stringify(message).substring(0, 500)}...`);
-    this.ws!.send(JSON.stringify(message));
+        turnComplete: true,
+      });
+      logger.info('VoiceService', `📤 Screen context sent (${domText.length} chars)`);
+    } catch (error: any) {
+      logger.error('VoiceService', `sendScreenContext failed: ${error.message}`);
+    }
   }
 
   // ─── Send Function Response ────────────────────────────────
 
-  /** Send function call result back to Gemini */
+  /** Send function call result back via SDK's sendToolResponse */
   sendFunctionResponse(name: string, id: string, result: any): void {
-    if (!this.isConnected) return;
-
-    const message = {
-      toolResponse: {
-        functionResponses: [{
-          name,
-          id,
-          response: result,
-        }],
-      },
-    };
+    if (!this.isConnected || !this.session) return;
 
     logger.info('VoiceService', `📤 Sending tool response for ${name} (id=${id})`);
-    this.ws!.send(JSON.stringify(message));
+
+    try {
+      this.session.sendToolResponse({
+        functionResponses: [{ name, id, response: result }],
+      });
+    } catch (error: any) {
+      logger.error('VoiceService', `sendFunctionResponse failed: ${error.message}`);
+    }
   }
 
-  // ─── Internal: Setup ───────────────────────────────────────
+  // ─── Internal: Tool Declarations ───────────────────────────
 
   /**
-   * Builds and sends the setup message, replicating text mode's agent_step
-   * compound tool so the model uses structured reasoning + actions.
-   *
-   * The agent_step tool flattens reasoning fields (previous_goal_eval,
-   * memory, plan) + action_name enum + all action parameters into a single
-   * function — matching GeminiProvider.buildAgentStepDeclaration exactly.
+   * Builds function declarations from configured tools.
+   * Converts BOOLEAN params to STRING (native audio model limitation).
    */
-  private sendSetup(): void {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+  private buildToolDeclarations(): any[] {
+    if (!this.config.tools?.length) return [];
 
-    const model = this.config.model || DEFAULT_MODEL;
+    const validTools = this.config.tools.filter(t => t.name !== 'capture_screenshot');
+    if (validTools.length === 0) return [];
 
-    const setup: any = {
-      model: `models/${model}`,
-      generationConfig: {
-        responseModalities: ['AUDIO'],
-        // Note: Do NOT set thinkingBudget: 0 — it completely disables
-        // the model's ability to reason about when to call tools.
-        // The text thinking blocks are a trade-off for working function calling.
-      },
-    };
-
-    // Add system instruction if provided
-    if (this.config.systemPrompt) {
-      setup.systemInstruction = {
-        parts: [{ text: this.config.systemPrompt }],
+    return validTools.map(tool => {
+      const hasParams = Object.keys(tool.parameters || {}).length > 0;
+      const functionDecl: any = {
+        name: tool.name,
+        description: tool.description,
       };
-    }
 
-    // Add individual tool declarations for function calling
-    // NOTE: We use individual tools (tap, type, navigate, done, ask_user)
-    // instead of the compound agent_step used in text mode.
-    // The native audio model in real-time can call simple tools but struggles
-    // with the complex agent_step schema (it speaks about calling tools
-    // instead of actually calling them).
-    if (this.config.tools?.length) {
-      const validTools = this.config.tools.filter(t => t.name !== 'capture_screenshot');
-      if (validTools.length > 0) {
-        setup.tools = [{
-          functionDeclarations: validTools.map(tool => {
-            const hasParams = Object.keys(tool.parameters || {}).length > 0;
-            const functionDecl: any = {
-              name: tool.name,
-              description: tool.description,
-            };
-
-            if (hasParams) {
-              functionDecl.parameters = {
-                type: 'OBJECT',
-                properties: Object.fromEntries(
-                  Object.entries(tool.parameters).map(([key, param]) => {
-                    // Native audio model crashes with BOOLEAN/ENUM types (error 1008)
-                    // Convert to STRING as a workaround
-                    let paramType = param.type.toUpperCase();
-                    let desc = param.description;
-                    if (paramType === 'BOOLEAN') {
-                      paramType = 'STRING';
-                      desc = `${desc} (use "true" or "false")`;
-                    }
-                    return [
-                      key,
-                      {
-                        type: paramType,
-                        description: desc,
-                      },
-                    ];
-                  })
-                ),
-                required: Object.entries(tool.parameters)
-                  .filter(([, param]) => param.required)
-                  .map(([key]) => key),
-              };
-            }
-            return functionDecl;
-          }),
-        }];
+      if (hasParams) {
+        functionDecl.parameters = {
+          type: 'OBJECT',
+          properties: Object.fromEntries(
+            Object.entries(tool.parameters).map(([key, param]) => {
+              let paramType = param.type.toUpperCase();
+              let desc = param.description;
+              if (paramType === 'BOOLEAN') {
+                paramType = 'STRING';
+                desc = `${desc} (use "true" or "false")`;
+              }
+              return [key, { type: paramType, description: desc }];
+            })
+          ),
+          required: Object.entries(tool.parameters)
+            .filter(([, param]) => param.required)
+            .map(([key]) => key),
+        };
       }
-    }
-
-    const setupMessage = { setup };
-    logger.info('VoiceService', `Sending setup (model: ${model}, ${this.config.tools?.length || 0} tools)`);
-    try {
-      const payload = JSON.stringify(setupMessage);
-      logger.info('VoiceService', `📤 Raw Setup Payload: ${payload}`);
-      this.ws.send(payload);
-    } catch (err: any) {
-      logger.error('VoiceService', `❌ Error stringifying setup message: ${err.message}`);
-    }
+      return functionDecl;
+    });
   }
 
   // ─── Internal: Message Handling ────────────────────────────
 
-  private handleMessage(event: WebSocketMessageEvent): void {
+  /**
+   * Handle messages from the SDK's onmessage callback.
+   * The SDK parses binary/JSON automatically — we get clean objects.
+   *
+   * Per official docs, tool calls come at the top level as
+   * `response.toolCall.functionCalls`.
+   */
+  private handleSDKMessage(message: any): void {
     try {
-      const dataType = typeof event.data;
-      const dataLen = typeof event.data === 'string' ? event.data.length : (event.data?.byteLength || 'unknown');
-      logger.info('VoiceService', `📥 WS message received: type=${dataType}, length=${dataLen}`);
-
-      // Handle binary data (could be JSON or raw PCM)
-      if (typeof event.data !== 'string') {
-        logger.info('VoiceService', '📥 Binary message — processing...');
-        this.handleBinaryMessage(event.data);
+      // RAW MESSAGE DUMP — full session visibility
+      const msgKeys = Object.keys(message || {}).join(', ');
+      logger.info('VoiceService', `📨 SDK message keys: [${msgKeys}]`);
+
+      // Full raw dump for non-audio messages (audio is too large)
+      if (!message.serverContent?.modelTurn?.parts?.some((p: any) => p.inlineData)) {
+        const rawDump = JSON.stringify(message).substring(0, 1000);
+        logger.info('VoiceService', `📨 RAW: ${rawDump}`);
+      }
+
+      // Tool calls — top-level (per official docs)
+      if (message.toolCall?.functionCalls) {
+        this.handleToolCalls(message.toolCall.functionCalls);
         return;
       }
 
-      // Handle JSON text messages
-      const message = JSON.parse(event.data);
-      logger.info('VoiceService', `📥 JSON message keys: ${Object.keys(message).join(', ')}`);
-      logger.info('VoiceService', `📥 Raw JSON Message: ${event.data.substring(0, 1000)}`);
-      this.processMessage(message);
-    } catch (error: any) {
-      logger.error('VoiceService', `Error handling message: ${error.message}`);
-    }
-  }
+      // Server content (audio, text, transcripts, turn events)
+      if (message.serverContent) {
+        this.handleServerContent(message.serverContent);
+      }
 
-  private handleBinaryMessage(data: any): void {
-    try {
-      // Try to decode as JSON first
-      let bytes: Uint8Array;
-      if (data instanceof ArrayBuffer) {
-        bytes = new Uint8Array(data);
-      } else if (data instanceof Blob) {
-        // Blob handling — read as ArrayBuffer
-        const reader = new FileReader();
-        reader.onload = () => {
-          if (reader.result instanceof ArrayBuffer) {
-            this.processBinaryBytes(new Uint8Array(reader.result));
-          }
-        };
-        reader.readAsArrayBuffer(data);
-        return;
-      } else {
-        return;
+      // Setup complete acknowledgment
+      if (message.setupComplete !== undefined) {
+        logger.info('VoiceService', '✅ Setup complete — ready for audio');
+        this.callbacks.onSetupComplete?.();
       }
 
-      this.processBinaryBytes(bytes);
+      // Error messages
+      if (message.error) {
+        logger.error('VoiceService', `Server error: ${JSON.stringify(message.error)}`);
+        this.callbacks.onError?.(message.error.message || 'Server error');
+      }
     } catch (error: any) {
-      logger.error('VoiceService', `Error handling binary message: ${error.message}`);
+      logger.error('VoiceService', `Error handling SDK message: ${error.message}`);
     }
   }
 
-  private processBinaryBytes(bytes: Uint8Array): void {
-    // Check if it looks like JSON (starts with '{' or '[')
-    const looksLikeJson = bytes.length > 0 && (bytes[0] === 123 || bytes[0] === 91);
-
-    if (looksLikeJson) {
-      try {
-        const text = new TextDecoder('utf-8').decode(bytes);
-        const message = JSON.parse(text);
-        this.processMessage(message);
-      } catch {
-        // Not JSON — treat as raw PCM audio
-        this.callbacks.onAudioResponse?.(this.arrayBufferToBase64(bytes.buffer as ArrayBuffer));
-      }
-    } else {
-      // Raw PCM audio data
-      this.callbacks.onAudioResponse?.(this.arrayBufferToBase64(bytes.buffer as ArrayBuffer));
+  /** Process tool calls from the model */
+  private handleToolCalls(functionCalls: any[]): void {
+    for (const fn of functionCalls) {
+      logger.info('VoiceService', `🎯 Tool call: ${fn.name}(${JSON.stringify(fn.args)}) [id=${fn.id}]`);
+      this.callbacks.onToolCall?.({
+        name: fn.name,
+        args: fn.args || {},
+        id: fn.id,
+      });
     }
   }
 
-  private processMessage(message: any): void {
-    // Setup complete acknowledgment
-    if (message.setupComplete !== undefined) {
-      logger.info('VoiceService', '✅ Setup complete — ready for audio exchange');
-      this.setupComplete = true;
-      this.setStatus('connected');
-      return;
-    }
+  private audioResponseCount = 0;
 
-    // Server content (audio response + transcripts)
-    if (message.serverContent) {
-      const content = message.serverContent;
-      logger.info('VoiceService', `📥 serverContent received — turnComplete=${content.turnComplete}, hasParts=${!!content.modelTurn?.parts}, inputTranscription=${!!content.inputTranscription}, outputTranscription=${!!content.outputTranscription}`);
+  /** Process server content (audio responses, transcripts, turn events) */
+  private handleServerContent(content: any): void {
+    // Log all keys for full visibility
+    const contentKeys = Object.keys(content || {}).join(', ');
+    logger.debug('VoiceService', `📦 serverContent keys: [${contentKeys}]`);
 
-      // Check for turn complete
-      if (content.turnComplete) {
-        this.callbacks.onTurnComplete?.();
-      }
-
-      // Process model output parts
-      if (content.modelTurn?.parts) {
-        for (const part of content.modelTurn.parts) {
-          // Audio response
-          if (part.inlineData?.data) {
-            logger.info('VoiceService', `🔊 Audio response: ${part.inlineData.data.length} chars`);
-            this.callbacks.onAudioResponse?.(part.inlineData.data);
-          }
+    // Turn complete
+    if (content.turnComplete) {
+      logger.info('VoiceService', `🏁 Turn complete (audioChunks sent: ${this.audioResponseCount})`);
+      this.audioResponseCount = 0;
+      this.callbacks.onTurnComplete?.();
+    }
 
-          // Text response (transcript)
-          if (part.text) {
-            logger.info('VoiceService', `💬 Text response: "${part.text}"`);
-            this.callbacks.onTranscript?.(part.text, true, 'model');
+    // Model output parts (audio + optional thinking text)
+    if (content.modelTurn?.parts) {
+      for (const part of content.modelTurn.parts) {
+        if (part.inlineData?.data) {
+          this.audioResponseCount++;
+          if (this.audioResponseCount <= 3 || this.audioResponseCount % 20 === 0) {
+            logger.info('VoiceService', `🔊 Audio chunk #${this.audioResponseCount}: ${part.inlineData.data.length} b64 chars, mime=${part.inlineData.mimeType || 'unknown'}`);
           }
+          this.callbacks.onAudioResponse?.(part.inlineData.data);
+        }
+        if (part.text) {
+          logger.info('VoiceService', `🤖 MODEL: "${part.text}"`);
+          this.callbacks.onTranscript?.(part.text, true, 'model');
         }
       }
+    }
 
-      // Input transcription (user's speech)
-      if (content.inputTranscription?.text) {
-        this.callbacks.onTranscript?.(content.inputTranscription.text, true, 'user');
-      }
-
-      // Output transcription (model's speech-to-text)
-      if (content.outputTranscription?.text) {
-        this.callbacks.onTranscript?.(content.outputTranscription.text, true, 'model');
-      }
+    // Input transcription (user's speech-to-text)
+    if (content.inputTranscription?.text) {
+      logger.info('VoiceService', `🗣️ USER (voice): "${content.inputTranscription.text}"`);
+      this.callbacks.onTranscript?.(content.inputTranscription.text, true, 'user');
     }
 
-    // Tool calls from the model
-    if (message.toolCall?.functionCalls) {
-      for (const fn of message.toolCall.functionCalls) {
-        logger.info('VoiceService', `🎯 Tool call: ${fn.name}(${JSON.stringify(fn.args)})`);
-        this.callbacks.onToolCall?.({
-          name: fn.name,
-          args: fn.args || {},
-          id: fn.id,
-        });
-      }
+    // Output transcription (model's speech-to-text)
+    if (content.outputTranscription?.text) {
+      logger.info('VoiceService', `🤖 MODEL (voice): "${content.outputTranscription.text}"`);
+      this.callbacks.onTranscript?.(content.outputTranscription.text, true, 'model');
     }
 
-    // Error messages
-    if (message.error) {
-      logger.error('VoiceService', `Server error: ${JSON.stringify(message.error)}`);
-      this.callbacks.onError?.(message.error.message || 'Server error');
+    // Tool calls inside serverContent (some SDK versions deliver here)
+    if (content.toolCall?.functionCalls) {
+      this.handleToolCalls(content.toolCall.functionCalls);
     }
   }
 
@@ -435,13 +432,4 @@ export class VoiceService {
     this._status = newStatus;
     this.callbacks.onStatusChange?.(newStatus);
   }
-
-  private arrayBufferToBase64(buffer: ArrayBuffer): string {
-    const bytes = new Uint8Array(buffer);
-    let binary = '';
-    for (let i = 0; i < bytes.byteLength; i++) {
-      binary += String.fromCharCode(bytes[i]!);
-    }
-    return btoa(binary);
-  }
 }