@conversionpros/aiva 1.0.0

package/voice-call-local.js

@@ -0,0 +1,731 @@
+/**
+ * Local Voice Call Module for AIVA — Routes through Main Agent + Local TTS
+ * 
+ * Architecture:
+ * 1. Client sends PCM16 audio chunks
+ * 2. Server accumulates and transcribes via OpenAI Whisper
+ * 3. Transcription is sent to OpenClaw main agent (claude-sonnet-4-5)
+ * 4. Agent's text response is converted to speech via local TTS server
+ * 5. Audio is streamed back to client
+ */
+
+const WebSocket = require('ws');
+const fs = require('fs');
+const path = require('path');
+const { exec: execCb, execSync } = require('child_process');
+const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
+
+// Configuration
+const OPENCLAW_API = 'http://127.0.0.1:18789/v1/chat/completions';
+const OPENCLAW_AUTH = loadOpenClawAuth();
+const LOCAL_TTS_API = 'http://127.0.0.1:3851/tts';
+const CONTEXT_API = 'http://localhost:3847/api/context/voice';
+// STT: Local Whisper CLI (free, no API key needed)
+// LLM: OpenClaw proxy (free, existing subscription)
+// TTS: Kokoro TTS (free, local)
+
+// Active call sessions
+const activeCalls = new Map();
+
+function loadOpenClawAuth() {
+  try {
+    const configPath = path.join(process.env.HOME, '.openclaw', 'openclaw.json');
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    return config.gateway?.auth?.password || '';
+  } catch (e) {
+    console.error('[voice-call-local] Failed to load OpenClaw auth:', e.message);
+    return '';
+  }
+}
+
+async function fetchContext() {
+  try {
+    const res = await fetch(CONTEXT_API);
+    if (!res.ok) throw new Error(`Context API ${res.status}`);
+    return await res.json();
+  } catch (e) {
+    console.error('[voice-call-local] Failed to fetch context:', e.message);
+    return null;
+  }
+}
+
+function buildSystemPrompt(ctx) {
+  const now = new Date();
+  const timeStr = now.toLocaleString('en-US', { 
+    timeZone: 'America/Los_Angeles', 
+    weekday: 'long', 
+    year: 'numeric', 
+    month: 'long', 
+    day: 'numeric', 
+    hour: 'numeric', 
+    minute: '2-digit', 
+    hour12: true 
+  });
+
+  let prompt = `You are AIVA (AI-VA), Brandon Burgan's AI assistant. This is a voice conversation through the AIVA app.
+
+CURRENT DATE AND TIME: ${timeStr} (Pacific Time)
+
+VOICE CONVERSATION RULES (CRITICAL):
+- Keep responses SHORT and CONVERSATIONAL (1-3 sentences max)
+- Use contractions and casual language
+- NO markdown, bullet points, or formatting — everything is spoken aloud
+- Start with a brief greeting then WAIT for Brandon to tell you what he needs
+- Don't volunteer information (calendar, tasks) unless he asks
+- Be helpful and concise
+
+TASK RULES:
+- Unless explicitly asked, don't mention finished/done tasks
+- When listing tasks, default to non-done tasks only
+
+PERSONALITY:
+You are warm, efficient, and proactive. You understand Brandon's needs before he asks.`;
+
+  // Append dynamic context if available
+  if (ctx) {
+    if (ctx.activeTasks?.length) {
+      const tasks = ctx.activeTasks.slice(0, 10).map(t => `- ${t.title} (${t.status})`).join('\n');
+      prompt += `\n\nACTIVE TASKS (reference only — do NOT mention unless asked):\n${tasks}`;
+    }
+    if (ctx.recentChat?.length) {
+      const recent = ctx.recentChat.slice(-10).map(m => `${m.from}: ${m.text?.slice(0, 100)}`).join('\n');
+      prompt += `\n\nRECENT CHAT (reference only):\n${recent}`;
+    }
+    const calArray = Array.isArray(ctx.calendar) ? ctx.calendar : [];
+    if (calArray.length) {
+      const nowTime = new Date();
+      const futureEvents = calArray.filter(e => {
+        const eventTime = e.time || e.start || '';
+        if (!eventTime) return true;
+        try {
+          const eventDate = new Date(eventTime);
+          return eventDate > nowTime;
+        } catch { return true; }
+      });
+      if (futureEvents.length) {
+        const events = futureEvents.slice(0, 5).map(e => `- ${e.title || e.summary} (${e.time || e.start || ''})`).join('\n');
+        prompt += `\n\nUPCOMING CALENDAR (reference only — do NOT mention unless asked):\n${events}`;
+      }
+    }
+  }
+
+  return prompt;
+}
+
+async function transcribeAudio(audioBuffer) {
+  /**
+   * Transcribe audio buffer using OpenAI Whisper API.
+   * audioBuffer: Buffer containing audio data (WAV/PCM)
+   */
+  const FormData = (await import('form-data')).default;
+  
+  // Wrap raw PCM16 in a proper WAV header (24kHz, 16-bit, mono)
+  const sampleRate = 24000;
+  const numChannels = 1;
+  const bitsPerSample = 16;
+  const dataSize = audioBuffer.length;
+  const wavHeader = Buffer.alloc(44);
+  wavHeader.write('RIFF', 0);
+  wavHeader.writeUInt32LE(36 + dataSize, 4);
+  wavHeader.write('WAVE', 8);
+  wavHeader.write('fmt ', 12);
+  wavHeader.writeUInt32LE(16, 16);
+  wavHeader.writeUInt16LE(1, 20); // PCM
+  wavHeader.writeUInt16LE(numChannels, 22);
+  wavHeader.writeUInt32LE(sampleRate, 24);
+  wavHeader.writeUInt32LE(sampleRate * numChannels * bitsPerSample / 8, 28);
+  wavHeader.writeUInt16LE(numChannels * bitsPerSample / 8, 32);
+  wavHeader.writeUInt16LE(bitsPerSample, 34);
+  wavHeader.write('data', 36);
+  wavHeader.writeUInt32LE(dataSize, 40);
+  
+  const tempPath = path.join('/tmp', `voice-${Date.now()}.wav`);
+  fs.writeFileSync(tempPath, Buffer.concat([wavHeader, audioBuffer]));
+  
+  try {
+    // Convert to proper format for Whisper (if needed)
+    const convertedPath = tempPath.replace('.wav', '-converted.wav');
+    try {
+      execSync(`ffmpeg -y -i "${tempPath}" -ar 16000 -ac 1 -acodec pcm_s16le "${convertedPath}" 2>/dev/null`);
+      fs.unlinkSync(tempPath);
+    } catch (e) {
+      // If conversion fails, use original
+      fs.renameSync(tempPath, convertedPath);
+    }
+    
+    // Use LOCAL Whisper CLI (free, no API key needed)
+    const result = execSync(
+      `whisper "${convertedPath}" --model tiny --language en --output_format txt --output_dir /tmp 2>/dev/null`,
+      { timeout: 30000 }
+    ).toString().trim();
+    
+    // Read the output text file
+    const txtPath = convertedPath.replace('.wav', '.txt');
+    let transcript = '';
+    if (fs.existsSync(txtPath)) {
+      transcript = fs.readFileSync(txtPath, 'utf-8').trim();
+      fs.unlinkSync(txtPath);
+    } else {
+      // Sometimes whisper outputs to stdout
+      transcript = result;
+    }
+    
+    // Clean up audio files
+    if (fs.existsSync(convertedPath)) fs.unlinkSync(convertedPath);
+    // Clean up any other whisper output files
+    for (const ext of ['.vtt', '.srt', '.tsv', '.json']) {
+      const f = convertedPath.replace('.wav', ext);
+      if (fs.existsSync(f)) fs.unlinkSync(f);
+    }
+    
+    return transcript;
+  } catch (e) {
+    console.error('[voice-call-local] Transcription error:', e.message);
+    if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+    throw e;
+  }
+}
+
+function stripToolMarkup(text) {
+  if (text.includes('Exec:') || text.includes('```') || text.includes('curl ') || text.includes('🛠️')) {
+    console.warn('[voice-call-local] Stripping tool markup from response');
+    text = text.replace(/⚠️.*$/gm, '').replace(/🛠️.*$/gm, '').replace(/```[\s\S]*?```/g, '').replace(/`[^`]+`/g, '').trim();
+    if (!text || text.length < 5) {
+      text = "Hey! Sorry, I had a hiccup there. What were you saying?";
+    }
+  }
+  return text;
+}
+
+/**
+ * Stream LLM response with sentence-level TTS chunking.
+ * Calls onSentence(sentenceText, audioBase64) for each complete sentence.
+ * Returns the full assembled response text.
+ */
+async function queryMainAgentStreaming(messages, systemPrompt, { onSentence, onDone } = {}) {
+  const basePayload = {
+    model: 'claude-sonnet-4-5',
+    messages: [
+      { role: 'system', content: systemPrompt + '\n\nCRITICAL: You are in a VOICE conversation. Respond with plain spoken text ONLY. Do NOT use any tools, commands, code blocks, markdown, or special formatting. Just talk naturally.' },
+      ...messages
+    ],
+    max_tokens: 500,
+    temperature: 0.7,
+    user: 'voice-call-brandon'
+  };
+
+  const delays = [0, 3000, 8000];
+  for (let attempt = 0; attempt < delays.length; attempt++) {
+    if (delays[attempt] > 0) await new Promise(r => setTimeout(r, delays[attempt]));
+    const useStream = attempt === 0; // fallback to non-streaming on retries
+    try {
+      const payload = { ...basePayload, ...(useStream ? { stream: true } : {}) };
+      const response = await fetch(OPENCLAW_API, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${OPENCLAW_AUTH}`,
+          'x-openclaw-agent-id': 'voice',
+          'x-openclaw-session-key': 'agent:voice:openai-user:voice-call-brandon'
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        const err = await response.text();
+        console.error(`[voice-call-local] Proxy attempt ${attempt+1} failed: ${response.status} ${err.substring(0, 100)}`);
+        continue;
+      }
+
+      if (!useStream) {
+        // Non-streaming fallback
+        const result = await response.json();
+        let text = stripToolMarkup(result.choices?.[0]?.message?.content || '');
+        if (!text || text.includes('No response from OpenClaw')) continue;
+        console.log('[voice-call-local] Got response via OpenClaw proxy (non-streaming fallback)');
+        if (onSentence) {
+          try {
+            const audio = await generateSpeech(text);
+            onSentence(text, audio.toString('base64'));
+          } catch (e) { console.error('[voice-call-local] TTS error in fallback:', e.message); }
+        }
+        if (onDone) onDone();
+        return text;
+      }
+
+      // Streaming path: parse SSE
+      console.log('[voice-call-local] Streaming response from proxy...');
+      let fullText = '';
+      let sentenceBuffer = '';
+      const ttsPromises = []; // track in-flight TTS to await at end
+
+      const processCompleteSentences = async (flush = false) => {
+        // Find sentence boundaries
+        const sentenceEndRegex = /([.!?])\s+/g;
+        let match;
+        let lastEnd = 0;
+        const sentences = [];
+
+        while ((match = sentenceEndRegex.exec(sentenceBuffer)) !== null) {
+          sentences.push(sentenceBuffer.substring(lastEnd, match.index + 1));
+          lastEnd = match.index + match[0].length;
+        }
+
+        if (sentences.length > 0) {
+          sentenceBuffer = sentenceBuffer.substring(lastEnd);
+          for (const sentence of sentences) {
+            const cleaned = stripToolMarkup(sentence.trim());
+            if (cleaned.length < 2) continue;
+            if (onSentence) {
+              const p = (async () => {
+                try {
+                  const audio = await generateSpeech(cleaned);
+                  onSentence(cleaned, audio.toString('base64'));
+                } catch (e) { console.error('[voice-call-local] TTS chunk error:', e.message); }
+              })();
+              ttsPromises.push(p);
+            }
+          }
+        }
+
+        if (flush && sentenceBuffer.trim().length > 1) {
+          const cleaned = stripToolMarkup(sentenceBuffer.trim());
+          sentenceBuffer = '';
+          if (cleaned.length >= 2 && onSentence) {
+            const p = (async () => {
+              try {
+                const audio = await generateSpeech(cleaned);
+                onSentence(cleaned, audio.toString('base64'));
+              } catch (e) { console.error('[voice-call-local] TTS flush error:', e.message); }
+            })();
+            ttsPromises.push(p);
+          }
+        }
+      };
+
+      // Read SSE stream
+      const reader = response.body;
+      let remainder = '';
+
+      await new Promise((resolve, reject) => {
+        reader.on('data', (chunk) => {
+          const text = remainder + chunk.toString();
+          const lines = text.split('\n');
+          remainder = lines.pop() || '';
+
+          for (const line of lines) {
+            if (!line.startsWith('data: ')) continue;
+            const data = line.slice(6).trim();
+            if (data === '[DONE]') continue;
+            try {
+              const parsed = JSON.parse(data);
+              const delta = parsed.choices?.[0]?.delta?.content || '';
+              if (delta) {
+                fullText += delta;
+                sentenceBuffer += delta;
+                processCompleteSentences(false);
+              }
+            } catch (e) { /* ignore parse errors on SSE lines */ }
+          }
+        });
+        reader.on('end', resolve);
+        reader.on('error', reject);
+      });
+
+      // Flush remaining text
+      await processCompleteSentences(true);
+      // Wait for all TTS chunks to finish
+      await Promise.all(ttsPromises);
+
+      fullText = stripToolMarkup(fullText);
+      if (!fullText || fullText.includes('No response from OpenClaw')) continue;
+
+      console.log('[voice-call-local] Streaming response complete:', fullText.substring(0, 100));
+      if (onDone) onDone();
+      return fullText;
+
+    } catch (e) {
+      console.error(`[voice-call-local] Proxy attempt ${attempt+1} error:`, e.message);
+    }
+  }
+
+  throw new Error('All proxy attempts failed');
+}
+
+// Legacy non-streaming wrapper for compatibility
+async function queryMainAgent(messages, systemPrompt) {
+  return queryMainAgentStreaming(messages, systemPrompt);
+}
+
+// Add 20ms fade-in to prevent audio pop/click at start of TTS playback
+function addFadeIn(audioBuffer, durationMs = 20) {
+  const headerSize = 44; // WAV header
+  const sampleRate = 24000; // Kokoro default
+  const fadeSamples = Math.floor(sampleRate * durationMs / 1000);
+  const buf = Buffer.from(audioBuffer);
+  
+  for (let i = 0; i < fadeSamples && (headerSize + i * 2 + 1) < buf.length; i++) {
+    const offset = headerSize + i * 2;
+    const sample = buf.readInt16LE(offset);
+    const gain = i / fadeSamples; // 0.0 to 1.0
+    buf.writeInt16LE(Math.round(sample * gain), offset);
+  }
+  return buf;
+}
+
+async function generateSpeech(text) {
+  /**
+   * Generate speech from text using local TTS server.
+   * Returns audio buffer with fade-in applied.
+   */
+  try {
+    const response = await fetch(LOCAL_TTS_API, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text, rate: 200 })
+    });
+    
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`TTS error: ${error}`);
+    }
+    
+    const arrayBuffer = await response.arrayBuffer();
+    return addFadeIn(Buffer.from(arrayBuffer));
+  } catch (e) {
+    console.error('[voice-call-local] TTS error:', e.message);
+    throw e;
+  }
+}
+
+function setupVoiceCall(io) {
+  io.on('connection', (socket) => {
+    
+    socket.on('voice-call-start', async (data) => {
+      console.log('[voice-call-local] Call started by:', data?.userId || 'unknown');
+      
+      // Fetch context for system prompt
+      const ctx = await fetchContext().catch(() => null);
+      const systemPrompt = buildSystemPrompt(ctx);
+      
+      const callSession = {
+        id: Date.now().toString(),
+        userId: data?.userId || 'brandon',
+        startedAt: new Date().toISOString(),
+        transcript: [],  // Full conversation history
+        messages: [],    // OpenAI-format messages for context
+        systemPrompt,
+        audioBuffer: null,  // Accumulator for incoming audio chunks
+        isRecording: false,
+        processingResponse: false
+      };
+      
+      activeCalls.set(socket.id, callSession);
+      
+      // Auto-start recording (frontend sends continuous audio stream)
+      callSession.isRecording = true;
+      callSession.audioBuffer = Buffer.alloc(0);
+      
+      // Set up silence detection — process audio after 2s of silence
+      callSession.silenceTimer = null;
+      callSession.lastAudioTime = Date.now();
+      
+      // Send ready signal
+      socket.emit('voice-call-ready', { callId: callSession.id });
+      socket.emit('voice-call-status', { status: 'listening' });
+      console.log('[voice-call-local] Call ready:', callSession.id);
+    });
+    
+    // User starts speaking (push-to-talk or VAD trigger)
+    socket.on('voice-call-start-recording', () => {
+      const session = activeCalls.get(socket.id);
+      if (!session) return;
+      
+      session.isRecording = true;
+      session.audioBuffer = Buffer.alloc(0);
+      socket.emit('voice-call-status', { status: 'recording' });
+      console.log('[voice-call-local] Recording started');
+    });
+    
+    // Receive audio chunks (continuous stream with silence detection)
+    let chunkCount = 0;
+    socket.on('voice-call-audio-chunk', (data) => {
+      const session = activeCalls.get(socket.id);
+      if (!session || !session.isRecording || session.processingResponse) return;
+      
+      if (data?.audio) {
+        const chunk = Buffer.from(data.audio, 'base64');
+        
+        // Check if this chunk has meaningful audio (not silence)
+        const samples = new Int16Array(chunk.buffer, chunk.byteOffset, chunk.length / 2);
+        let rms = 0;
+        for (let i = 0; i < samples.length; i++) rms += samples[i] * samples[i];
+        rms = Math.sqrt(rms / samples.length);
+        
+        // Barge-in: user speaks while agent is playing TTS
+        if (session.isPlaying && rms > 1000) {
+          console.log('[voice-call-local] Barge-in detected! Stopping playback.');
+          session.isPlaying = false;
+          session.audioBuffer = Buffer.alloc(0);
+          session.hasVoice = true;
+          session.lastAudioTime = Date.now();
+          if (session.silenceTimer) { clearTimeout(session.silenceTimer); session.silenceTimer = null; }
+          socket.emit('voice-call-barge-in', {});
+        }
+        
+        // Don't accumulate audio while TTS is playing (unless barge-in just triggered above)
+        if (session.isPlaying) return;
+        
+        session.audioBuffer = Buffer.concat([session.audioBuffer, chunk]);
+        chunkCount++;
+        if (chunkCount % 50 === 1) console.log(`[voice-call-local] Chunk #${chunkCount}, buffer: ${session.audioBuffer.length} bytes`);
+        
+        if (chunkCount % 50 === 1) console.log(`[voice-call-local] RMS: ${Math.round(rms)}, hasVoice: ${!!session.hasVoice}`);
+        if (rms > 1000) { // Voice detected
+          session.lastAudioTime = Date.now();
+          if (!session.hasVoice) {
+            session.hasVoice = true;
+            console.log('[voice-call-local] Voice detected! RMS:', Math.round(rms));
+            socket.emit('voice-call-status', { status: 'recording' });
+          }
+        }
+        
+        // If voice is active again, cancel the silence timer (they're still talking)
+        if (rms > 1000) {
+          if (session.silenceTimer) { clearTimeout(session.silenceTimer); session.silenceTimer = null; }
+        }
+        
+        // After voice was detected, if we're now in silence, start the timer (only once)
+        if (session.hasVoice && rms <= 1000 && !session.silenceTimer) {
+          session.silenceTimer = setTimeout(async () => {
+            session.silenceTimer = null; // Clear reference so new timer can start
+            if (!session.isRecording || session.processingResponse) return;
+            if (session.audioBuffer.length < 16000) return; // Too short
+            
+            session.processingResponse = true;
+            session.hasVoice = false;
+            console.log('[voice-call-local] Silence detected, processing...');
+            socket.emit('voice-call-status', { status: 'processing' });
+            
+            try {
+              console.log('[voice-call-local] Transcribing audio...', session.audioBuffer.length, 'bytes');
+              const transcript = await transcribeAudio(session.audioBuffer);
+              
+              if (!transcript) {
+                socket.emit('voice-call-status', { status: 'listening' });
+                session.audioBuffer = Buffer.alloc(0);
+                session.processingResponse = false;
+                return;
+              }
+              
+              // Filter Whisper hallucinations
+              const hallucinations = ['thank you', 'thanks for watching', 'thank you for watching', 'bye', 'you', 'the end', "i'm sorry", 'goodbye', 'well congratulations', 'thanks', 'okay'];
+              const normalized = transcript.toLowerCase().replace(/[.,!?]/g, '').trim();
+              if ((hallucinations.includes(normalized) || normalized.length < 3) && session.audioBuffer.length < 144000) {
+                console.log('[voice-call-local] Filtered likely hallucination:', transcript);
+                session.audioBuffer = Buffer.alloc(0);
+                session.processingResponse = false;
+                socket.emit('voice-call-status', { status: 'listening' });
+                return;
+              }
+              
+              console.log('[voice-call-local] User said:', transcript);
+              socket.emit('voice-call-user-transcript', { text: transcript });
+              
+              // Get AI response
+              session.messages.push({ role: 'user', content: transcript });
+              session.transcript.push({ role: 'user', text: transcript, ts: new Date().toISOString() });
+              
+              session.isPlaying = true;
+              const aiResponse = await queryMainAgentStreaming(session.messages, session.systemPrompt, {
+                onSentence: (text, audioBase64) => {
+                  socket.emit('voice-call-transcript-delta', { text });
+                  socket.emit('voice-call-audio-delta', { audio: audioBase64 });
+                },
+                onDone: () => { session.isPlaying = false; socket.emit('voice-call-response-done', {}); }
+              });
+              console.log('[voice-call-local] Agent response:', aiResponse?.substring(0, 100));
+              
+              if (aiResponse) {
+                session.messages.push({ role: 'assistant', content: aiResponse });
+                session.transcript.push({ role: 'assistant', text: aiResponse, ts: new Date().toISOString() });
+              }
+            } catch (e) {
+              console.error('[voice-call-local] Processing error:', e.message);
+              socket.emit('voice-call-error', { error: e.message });
+            }
+            
+            session.audioBuffer = Buffer.alloc(0);
+            session.processingResponse = false;
+            socket.emit('voice-call-status', { status: 'listening' });
+          }, 1500); // Allow natural pauses between sentences
+        }
+      }
+    });
+    
+    // User stops speaking
+    socket.on('voice-call-stop-recording', async () => {
+      const session = activeCalls.get(socket.id);
+      if (!session || !session.isRecording) return;
+      
+      session.isRecording = false;
+      socket.emit('voice-call-status', { status: 'processing' });
+      
+      try {
+        // Transcribe audio
+        console.log('[voice-call-local] Transcribing audio...');
+        const transcript = await transcribeAudio(session.audioBuffer);
+        
+        if (!transcript) {
+          socket.emit('voice-call-error', { error: 'Could not understand audio' });
+          socket.emit('voice-call-status', { status: 'listening' });
+          return;
+        }
+        
+        // Filter Whisper hallucinations
+        const hallucinations2 = ['thank you', 'thanks for watching', 'thank you for watching', 'bye', 'you', 'the end', "i'm sorry", 'goodbye', 'well congratulations', 'thanks', 'okay'];
+        const normalized2 = transcript.toLowerCase().replace(/[.,!?]/g, '').trim();
+        if ((hallucinations2.includes(normalized2) || normalized2.length < 3) && session.audioBuffer.length < 144000) {
+          console.log('[voice-call-local] Filtered likely hallucination:', transcript);
+          session.audioBuffer = Buffer.alloc(0);
+          session.processingResponse = false;
+          socket.emit('voice-call-status', { status: 'listening' });
+          return;
+        }
+        
+        console.log('[voice-call-local] User said:', transcript);
+        session.transcript.push({ role: 'user', text: transcript });
+        session.messages.push({ role: 'user', content: transcript });
+        socket.emit('voice-call-user-transcript', { text: transcript });
+        
+        // Query main agent with streaming
+        console.log('[voice-call-local] Querying main agent (streaming)...');
+        session.processingResponse = true;
+        socket.emit('voice-call-status', { status: 'thinking' });
+        
+        let firstChunkSent = false;
+        session.isPlaying = true;
+        const responseText = await queryMainAgentStreaming(session.messages, session.systemPrompt, {
+          onSentence: (text, audioBase64) => {
+            if (!firstChunkSent) {
+              socket.emit('voice-call-status', { status: 'speaking' });
+              firstChunkSent = true;
+            }
+            socket.emit('voice-call-transcript-delta', { text });
+            socket.emit('voice-call-audio-delta', { audio: audioBase64 });
+            // Also emit legacy event for compatibility
+            socket.emit('voice-call-audio-response', { audio: audioBase64, text });
+          },
+          onDone: () => { session.isPlaying = false; socket.emit('voice-call-response-done', { text: '' }); }
+        });
+        
+        if (!responseText) {
+          throw new Error('No response from agent');
+        }
+        
+        console.log('[voice-call-local] Agent responded:', responseText.substring(0, 100));
+        session.transcript.push({ role: 'assistant', text: responseText });
+        session.messages.push({ role: 'assistant', content: responseText });
+        
+        console.log('[voice-call-local] Response sent (streamed)');
+        socket.emit('voice-call-status', { status: 'listening' });
+        session.processingResponse = false;
+        
+      } catch (e) {
+        console.error('[voice-call-local] Processing error:', e.message);
+        socket.emit('voice-call-error', { error: e.message });
+        socket.emit('voice-call-status', { status: 'listening' });
+        session.processingResponse = false;
+      }
+    });
+    
+    socket.on('voice-call-end', () => {
+      const session = activeCalls.get(socket.id);
+      if (!session) return;
+      cleanupCall(socket.id, session);
+    });
+    
+    socket.on('disconnect', () => {
+      const session = activeCalls.get(socket.id);
+      if (session) {
+        console.log('[voice-call-local] Socket disconnected, cleaning up call');
+        cleanupCall(socket.id, session);
+      }
+    });
+  });
+  
+  function cleanupCall(socketId, session) {
+    console.log(`[voice-call-local] Call ended (${session.transcript.length} turns)`);
+    
+    // Save transcript if there was conversation
+    if (session.transcript.length > 0) {
+      try {
+        const logDir = path.join(process.env.HOME || '', '.openclaw', 'workspace', 'memory', 'call-logs');
+        fs.mkdirSync(logDir, { recursive: true });
+        const ts = new Date().toISOString().replace(/[:.]/g, '-');
+        const pendingFile = path.join(logDir, `pending_local_${ts}.json`);
+        
+        // Calculate duration
+        const startTime = new Date(session.startedAt).getTime();
+        const endTime = Date.now();
+        const durationSeconds = Math.round((endTime - startTime) / 1000);
+        const durationMin = Math.floor(durationSeconds / 60);
+        const durationSec = durationSeconds % 60;
+        
+        const logData = {
+          type: 'local-voice-call',
+          timestamp: new Date().toISOString(),
+          duration: durationSeconds,
+          transcript: session.transcript,
+        };
+        
+        fs.writeFileSync(pendingFile, JSON.stringify(logData, null, 2));
+        console.log(`[voice-call-local] Transcript saved: ${pendingFile}`);
+        
+        // Fire wake hook to main agent with full transcript
+        const readableTranscript = session.transcript.map(t => 
+          `${t.role === 'user' ? 'Brandon' : 'AIVA'}: ${t.text}`
+        ).join('\n');
+        
+        const wakeText = `[VOICE-CALL-COMPLETE] Voice call with Brandon just ended. Duration: ${durationMin}m ${durationSec}s.\n\nFull transcript:\n${readableTranscript}\n\nProcess any action items from this conversation immediately. If Brandon asked for something to be done, delegate it. If there are insights about Brandon's preferences or decisions, log them to memory.`;
+        
+        // Send transcript directly to main agent via sessions_send
+        const invokeData = JSON.stringify({
+            tool: 'sessions_send',
+            args: {
+                sessionKey: 'agent:main:main',
+                message: wakeText
+            }
+        });
+
+        const invokeReq = require('http').request({
+            hostname: '127.0.0.1',
+            port: 18789,
+            path: '/tools/invoke',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${OPENCLAW_AUTH}`
+            }
+        }, (res) => {
+            let body = '';
+            res.on('data', d => body += d);
+            res.on('end', () => {
+                console.log(`[voice-call-local] sessions_send result: ${res.statusCode}`);
+            });
+        });
+        invokeReq.on('error', e => console.error('[voice-call-local] sessions_send failed:', e.message));
+        invokeReq.write(invokeData);
+        invokeReq.end();
+        
+      } catch (e) {
+        console.error('[voice-call-local] Failed to save transcript:', e.message);
+      }
+    }
+    
+    activeCalls.delete(socketId);
+  }
+  
+  console.log('[voice-call-local] Voice call handler initialized (Local TTS + Main Agent)');
+}
+
+module.exports = { setupVoiceCall };