@conversionpros/aiva 1.0.0

package/voice-call.js

@@ -0,0 +1,732 @@
+/**
+ * In-App Voice Call Module for AIVA — xAI Voice Agent API
+ * 
+ * Real-time bidirectional voice via xAI's Realtime WebSocket API (Ara voice).
+ * Client streams PCM16 audio → server proxies to xAI → streams audio back.
+ * xAI handles VAD (voice activity detection) — no push-to-talk needed.
+ */
+
+const WebSocket = require('ws');
+const fs = require('fs');
+const path = require('path');
+const { exec: execCb } = require('child_process');
+
+const { execSync } = require('child_process');
+
+const XAI_API_KEY = process.env.XAI_API_KEY || 'xai-Gn37fuJg5ty4gvWFG2rbth34AxNORUKH8r4vTXQDtjwMGUqKZ7nYy8u2YStosGUCVBEg7VMHSqQZcKS4';
+const XAI_WS_URL = 'wss://api.x.ai/v1/realtime';
+const CONTEXT_API = 'http://localhost:3847/api/context/voice';
+
+// Active call sessions
+const activeCalls = new Map();
+
+// (dedup tracking is now per-session — see callSession)
+
+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] Failed to fetch context:', e.message);
+    return null;
+  }
+}
+
+async function fetchLiveData() {
+  const result = { tasks: '', todayCalendar: '', weekCalendar: '' };
+  const now = new Date();
+  const fmt = (d) => d.toISOString().split('T')[0];
+  const addDays = (d, n) => { const r = new Date(d); r.setDate(r.getDate() + n); return r; };
+
+  // 1. Fetch open tasks
+  try {
+    const res = await fetch(TASK_API, { headers: INTERNAL_HEADERS });
+    if (res.ok) {
+      let tasks = await res.json();
+      if (Array.isArray(tasks.tasks)) tasks = tasks.tasks;
+      const open = (Array.isArray(tasks) ? tasks : []).filter(t => t.status !== 'done');
+      if (open.length) {
+        result.tasks = open.map(t => `- ${t.title} (${t.status}, assigned to ${t.assignee || 'unassigned'})`).join('\n');
+      }
+    }
+  } catch (e) {
+    console.error('[voice-call] Failed to pre-fetch tasks:', e.message);
+  }
+
+  // 2. Fetch today's calendar
+  try {
+    const today = fmt(now);
+    const tomorrow = fmt(addDays(now, 1));
+    const accounts = ['brandon@conversionmarketingpros.com', 'burgan.brandon@gmail.com'];
+    let allLines = [];
+    for (const acct of accounts) {
+      try {
+        const raw = execSync(`gog calendar list --account ${acct} --from ${today} --to ${tomorrow}`, { timeout: 10000, encoding: 'utf-8' }).trim();
+        if (raw) {
+          const lines = raw.split('\n').filter(l => !l.startsWith('ID ') && !l.startsWith('#') && l.trim());
+          // Skip "Busy" entries (free/busy from secondary calendars)
+          allLines.push(...lines.filter(l => !l.includes('Busy')));
+        }
+      } catch (e) { /* skip failed account */ }
+    }
+    // Filter out past events
+    if (allLines.length) {
+      const remaining = allLines.filter(line => {
+        const timeMatch = line.match(/(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2})/);
+        if (timeMatch) {
+          const eventTime = new Date(timeMatch[1].replace(' ', 'T'));
+          return eventTime > now;
+        }
+        return true;
+      });
+      result.todayCalendar = remaining.join('\n');
+    }
+  } catch (e) {
+    console.error('[voice-call] Failed to pre-fetch today calendar:', e.message);
+  }
+
+  // 3. Fetch this week's calendar
+  try {
+    const today = fmt(now);
+    const weekEnd = fmt(addDays(now, 7));
+    const accounts2 = ['brandon@conversionmarketingpros.com', 'burgan.brandon@gmail.com'];
+    let weekLines = [];
+    for (const acct of accounts2) {
+      try {
+        const raw = execSync(`gog calendar list --account ${acct} --from ${today} --to ${weekEnd}`, { timeout: 10000, encoding: 'utf-8' }).trim();
+        if (raw) {
+          const lines = raw.split('\n').filter(l => !l.startsWith('ID ') && !l.startsWith('#') && l.trim());
+          weekLines.push(...lines.filter(l => !l.includes('Busy')));
+        }
+      } catch (e) { /* skip failed account */ }
+    }
+    // Filter out past events from this week too
+      weekLines = weekLines.filter(line => {
+        const timeMatch = line.match(/(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2})/);
+        if (timeMatch) {
+          const eventTime = new Date(timeMatch[1].replace(' ', 'T'));
+          return eventTime > now;
+        }
+        return true;
+      });
+    if (weekLines.length) result.weekCalendar = weekLines.join('\n');
+  } catch (e) {
+    console.error('[voice-call] Failed to pre-fetch week calendar:', e.message);
+  }
+
+  return result;
+}
+
+function readPersonalityFiles() {
+  const workspacePath = path.join(process.env.HOME || '', '.openclaw', 'workspace');
+  const files = ['SOUL.md', 'USER.md', 'IDENTITY.md'];
+  const contents = {};
+  for (const file of files) {
+    try {
+      contents[file] = fs.readFileSync(path.join(workspacePath, file), 'utf-8');
+    } catch (e) {
+      console.error(`[voice-call] Failed to read ${file}:`, e.message);
+      contents[file] = '';
+    }
+  }
+  return contents;
+}
+
+function buildSystemPrompt(ctx) {
+  // Read personality files fresh at call time
+  const personality = readPersonalityFiles();
+
+  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. You are speaking on a voice call through the AIVA app using the Ara voice. Embody the personality below completely — you ARE Aiva.
+
+CURRENT DATE AND TIME: ${timeStr} (Pacific Time)
+Use this to speak intelligently about schedules — if calendar events are in the past today, don't mention them as upcoming. Only reference events that haven't happened yet.
+When discussing calendar events, speak naturally using the event names directly — say "You've got a meeting with Daniel Wee at 9" not "You have a calendar event called Daniel Wee." Treat events like a human assistant would describe a schedule.
+
+TASK RULES:
+- Unless explicitly asked, don't mention finished/done tasks. Brandon only cares about what's still open (to do, in progress, needs review).
+- When listing tasks, default to non-done tasks only.
+
+CRITICAL VOICE RULES:
+- Keep responses concise (1-3 sentences). This is a voice call, not a text chat.
+- Use contractions. Be casual and natural.
+- No markdown, bullet points, or formatting — everything is spoken aloud.
+- No emojis or special characters.
+- Start the conversation with a brief, casual greeting like "Hey Brandon, what's up?" and WAIT for the user to speak. Do NOT volunteer any information (calendar, tasks, etc.) until the user tells you what they need. Your job is to listen first, then assist. Only bring up calendar/tasks/context when the user asks or when it's directly relevant to what they're discussing.`;
+
+  if (personality['SOUL.md']) prompt += `\n\n--- PERSONALITY & VALUES ---\n${personality['SOUL.md']}`;
+  if (personality['USER.md']) prompt += `\n\n--- ABOUT BRANDON ---\n${personality['USER.md']}`;
+  if (personality['IDENTITY.md']) prompt += `\n\n--- IDENTITY ---\n${personality['IDENTITY.md']}`;
+
+  // Append dynamic context
+  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 context (reference only):\n${recent}`;
+    }
+    if (ctx.calendar?.length) {
+      const now = new Date();
+      const futureEvents = ctx.calendar.filter(e => {
+        const eventTime = e.time || e.start || '';
+        if (!eventTime) return true;
+        try {
+          const eventDate = new Date(eventTime);
+          return eventDate > now;
+        } 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 events (reference only — do NOT mention unless asked):\n${events}`;
+      }
+    }
+  }
+
+  return prompt;
+}
+
+// ── Tool definitions for xAI voice agent ──
+const VOICE_TOOLS = [
+  {
+    type: 'function',
+    name: 'create_task',
+    description: "Create a new task on the AIVA task board. Use this when Brandon asks you to add a task, create a to-do, or remember to do something.",
+    parameters: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Task title' },
+        description: { type: 'string', description: 'Task description or details' },
+        priority: { type: 'string', enum: ['low', 'normal', 'high'], description: 'Task priority' },
+        assignee: { type: 'string', description: 'Who to assign to (default: aiva)' },
+      },
+      required: ['title'],
+    },
+  },
+  {
+    type: 'function',
+    name: 'list_tasks',
+    description: "List tasks on the AIVA task board. Use when Brandon asks what's on the board, what tasks are pending, or what's in progress.",
+    parameters: {
+      type: 'object',
+      properties: {
+        status: { type: 'string', enum: ['todo', 'in-progress', 'needs-review', 'done', 'all'], description: 'Filter by status. Use "todo" for to-do items, "in-progress" for in progress, etc.' },
+      },
+    },
+  },
+  {
+    type: 'function',
+    name: 'update_task',
+    description: 'Update an existing task (change status, add notes, reassign). Use when Brandon says to move a task, mark something done, or add details to a task.',
+    parameters: {
+      type: 'object',
+      properties: {
+        task_title: { type: 'string', description: 'Title or partial title to find the task' },
+        status: { type: 'string', enum: ['todo', 'in-progress', 'needs-review', 'done'] },
+        notes: { type: 'string', description: 'Note to add to the task' },
+        assignee: { type: 'string', description: 'Reassign to someone' },
+      },
+      required: ['task_title'],
+    },
+  },
+  {
+    type: 'function',
+    name: 'check_calendar',
+    description: "Check Brandon's calendar for today or upcoming events. Use when he asks about his schedule, meetings, or what's coming up.",
+    parameters: {
+      type: 'object',
+      properties: {
+        timeframe: { type: 'string', enum: ['today', 'tomorrow', 'this_week', 'this_month'], description: 'Time range to check' },
+      },
+    },
+  },
+  {
+    type: 'function',
+    name: 'send_message',
+    description: 'Send a text message in the AIVA app chat. Use when Brandon asks you to write something down, send a note, or post a message.',
+    parameters: {
+      type: 'object',
+      properties: {
+        message: { type: 'string', description: 'The message to send' },
+      },
+      required: ['message'],
+    },
+  },
+  {
+    type: 'function',
+    name: 'search_documents',
+    description: "Search through AIVA's workspace documents and memory files. Use when Brandon asks about past conversations, notes, or stored information.",
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    type: 'function',
+    name: 'generate_media',
+    description: 'Generate an image or video using AI. Use when Brandon asks you to create, generate, or make an image or video.',
+    parameters: {
+      type: 'object',
+      properties: {
+        type: { type: 'string', enum: ['image', 'video'], description: 'Type of media to generate' },
+        prompt: { type: 'string', description: 'Description of what to generate' },
+        duration: { type: 'number', description: 'Video duration in seconds (1-15, default 5)' },
+        aspect_ratio: { type: 'string', description: 'Aspect ratio (16:9, 9:16, 1:1, 4:3, etc.)' },
+      },
+      required: ['type', 'prompt'],
+    },
+  },
+];
+
+const TASK_API = 'http://localhost:3847/api/tasks';
+const INTERNAL_HEADERS = { 'Content-Type': 'application/json', 'x-aiva-internal': 'true' };
+
+async function executeTool(name, args) {
+  console.log(`[voice-call] Executing tool: ${name}`, args);
+  try {
+    switch (name) {
+      case 'create_task': {
+        const body = {
+          title: args.title,
+          description: args.description || '',
+          priority: args.priority || 'normal',
+          assignee: args.assignee || 'aiva',
+          status: 'todo',
+          requestedFor: 'brandon',
+        };
+        const res = await fetch(TASK_API, { method: 'POST', headers: INTERNAL_HEADERS, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`API ${res.status}`);
+        const task = await res.json();
+        return { success: true, message: `Task "${args.title}" created successfully.`, taskId: task.id || task._id };
+      }
+
+      case 'list_tasks': {
+        const res = await fetch(TASK_API, { headers: INTERNAL_HEADERS });
+        if (!res.ok) throw new Error(`API ${res.status}`);
+        let tasks = await res.json();
+        if (Array.isArray(tasks.tasks)) tasks = tasks.tasks;
+        if (args.status && args.status !== 'all') {
+          tasks = tasks.filter(t => t.status === args.status);
+        }
+        const statusLabel = { 'todo': 'to do', 'in-progress': 'in progress', 'needs-review': 'needs review', 'done': 'done' };
+        const summary = tasks.slice(0, 15).map(t => `${t.title} (${statusLabel[t.status] || t.status}, ${t.assignee || 'unassigned'})`);
+        return { success: true, count: tasks.length, tasks: summary };
+      }
+
+      case 'update_task': {
+        // Find task by title match
+        const res = await fetch(TASK_API, { headers: INTERNAL_HEADERS });
+        if (!res.ok) throw new Error(`API ${res.status}`);
+        let tasks = await res.json();
+        if (Array.isArray(tasks.tasks)) tasks = tasks.tasks;
+        const needle = args.task_title.toLowerCase();
+        const match = tasks.find(t => t.title.toLowerCase().includes(needle));
+        if (!match) return { success: false, message: `No task found matching "${args.task_title}"` };
+
+        const updates = {};
+        if (args.status) updates.status = args.status;
+        if (args.assignee) updates.assignee = args.assignee;
+        if (args.notes) updates.notes = (match.notes || '') + '\n' + args.notes;
+
+        const id = match.id || match._id;
+        const putRes = await fetch(`${TASK_API}/${id}`, { method: 'PUT', headers: INTERNAL_HEADERS, body: JSON.stringify(updates) });
+        if (!putRes.ok) throw new Error(`Update API ${putRes.status}`);
+        return { success: true, message: `Task "${match.title}" updated.` };
+      }
+
+      case 'check_calendar': {
+        const tf = args.timeframe || 'today';
+        let cmd;
+        const now = new Date();
+        const fmt = (d) => d.toISOString().split('T')[0];
+        const addDays = (d, n) => { const r = new Date(d); r.setDate(r.getDate() + n); return r; };
+        let fromDate, toDate;
+        if (tf === 'today') { fromDate = fmt(now); toDate = fmt(addDays(now, 1)); }
+        else if (tf === 'tomorrow') { fromDate = fmt(addDays(now, 1)); toDate = fmt(addDays(now, 2)); }
+        else if (tf === 'this_month') { fromDate = fmt(now); toDate = fmt(addDays(now, 30)); }
+        else { fromDate = fmt(now); toDate = fmt(addDays(now, 7)); }
+        const calAccounts = ['brandon@conversionmarketingpros.com', 'burgan.brandon@gmail.com'];
+        let calResults = [];
+        for (const acct of calAccounts) {
+          try {
+            const r = execSync(`gog calendar list --account ${acct} --from ${fromDate} --to ${toDate}`, { timeout: 10000, encoding: 'utf-8' }).trim();
+            if (r) calResults.push(...r.split('\n').filter(l => !l.startsWith('ID ') && !l.startsWith('#') && l.trim() && !l.includes('Busy')));
+          } catch (e) { /* skip */ }
+        }
+        // Filter past events for today view
+        if (tf === 'today') {
+          calResults = calResults.filter(line => {
+            const timeMatch = line.match(/(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2})/);
+            if (timeMatch) {
+              const eventTime = new Date(timeMatch[1].replace(' ', 'T'));
+              return eventTime > now;
+            }
+            return true;
+          });
+        }
+        return { success: true, calendar: calResults.join('\n') || 'No upcoming events today.' };
+      }
+
+      case 'send_message': {
+        const res = await fetch('http://localhost:3847/api/chat/aiva-reply', {
+          method: 'POST',
+          headers: INTERNAL_HEADERS,
+          body: JSON.stringify({ userId: 'brandon', text: args.message }),
+        });
+        if (!res.ok) throw new Error(`Chat API ${res.status}`);
+        return { success: true, message: 'Message sent to chat.' };
+      }
+
+      case 'search_documents': {
+        const q = args.query.replace(/['"\\]/g, '');
+        const searchPaths = [
+          path.join(process.env.HOME || '', '.openclaw', 'workspace', 'memory'),
+          path.join(process.env.HOME || '', '.openclaw', 'workspace', 'MEMORY.md'),
+        ];
+        return new Promise((resolve) => {
+          execCb(`grep -r -i -l "${q}" ${searchPaths.join(' ')} 2>/dev/null | head -5`, { timeout: 5000 }, (err, stdout) => {
+            const files = (stdout || '').trim().split('\n').filter(Boolean);
+            if (!files.length) {
+              resolve({ success: true, results: 'No matching documents found.' });
+              return;
+            }
+            // Read snippets from matching files
+            const snippets = files.map(f => {
+              try {
+                const content = fs.readFileSync(f, 'utf-8');
+                const lines = content.split('\n');
+                const matchLines = lines.filter(l => l.toLowerCase().includes(q.toLowerCase())).slice(0, 3);
+                return { file: path.basename(f), matches: matchLines.join(' | ') };
+              } catch { return { file: path.basename(f), matches: '(could not read)' }; }
+            });
+            resolve({ success: true, results: snippets });
+          });
+        });
+      }
+
+      case 'generate_media': {
+        const opts = {};
+        if (args.duration) opts.duration = args.duration;
+        if (args.aspect_ratio) opts.aspectRatio = args.aspect_ratio;
+        const genRes = await fetch('http://localhost:3847/api/generate', {
+          method: 'POST',
+          headers: INTERNAL_HEADERS,
+          body: JSON.stringify({ type: args.type, prompt: args.prompt, options: opts }),
+        });
+        if (!genRes.ok) {
+          const err = await genRes.text();
+          throw new Error(`Generate API ${genRes.status}: ${err}`);
+        }
+        const genData = await genRes.json();
+        const mediaType = args.type === 'video' ? 'video' : 'image';
+        return { success: true, message: `${mediaType} generated and saved to chat. Brandon can see it in the app.`, url: genData.url };
+      }
+
+      default:
+        return { success: false, message: `Unknown tool: ${name}` };
+    }
+  } catch (e) {
+    console.error(`[voice-call] Tool ${name} error:`, e.message);
+    return { success: false, message: `Error: ${e.message}` };
+  }
+}
+
+function setupVoiceCall(io) {
+  io.on('connection', (socket) => {
+
+    socket.on('voice-call-start', async (data) => {
+      console.log('[voice-call] Call started by:', data?.userId || 'unknown');
+
+      // Fetch context and live data for system prompt
+      const [ctx, liveData] = await Promise.all([
+        fetchContext().catch(() => null),
+        fetchLiveData().catch(() => ({ tasks: '', todayCalendar: '', weekCalendar: '' })),
+      ]);
+      let systemPrompt = buildSystemPrompt(ctx);
+
+      // Inject pre-fetched live data
+      const liveDataSections = [];
+      if (liveData.tasks) liveDataSections.push(`CURRENT TASKS (reference only — do NOT mention unless asked):\n${liveData.tasks}`);
+      if (liveData.todayCalendar) liveDataSections.push(`TODAY'S REMAINING CALENDAR (reference only — do NOT mention unless asked):\n${liveData.todayCalendar}`);
+      if (liveData.weekCalendar) liveDataSections.push(`THIS WEEK'S CALENDAR (reference only — do NOT mention unless asked):\n${liveData.weekCalendar}`);
+      if (liveDataSections.length) {
+        systemPrompt += '\n\n' + liveDataSections.join('\n\n');
+      }
+
+      // Open WebSocket to xAI
+      let xaiWs;
+      try {
+        xaiWs = new WebSocket(XAI_WS_URL, {
+          headers: { 'Authorization': `Bearer ${XAI_API_KEY}` },
+        });
+      } catch (e) {
+        console.error('[voice-call] Failed to create xAI WebSocket:', e.message);
+        socket.emit('voice-call-error', { error: 'Failed to connect to voice service' });
+        return;
+      }
+
+      const callSession = {
+        id: Date.now().toString(),
+        userId: data?.userId || 'brandon',
+        xaiWs,
+        startedAt: new Date().toISOString(),
+        transcript: [], // {role, text}
+        currentResponseText: '',
+        completedResponseTexts: [],  // track completed response texts
+        currentResponseId: null,     // track current response ID
+        suppressCurrentResponse: false,
+      };
+      activeCalls.set(socket.id, callSession);
+
+      xaiWs.on('open', () => {
+        console.log('[voice-call] xAI WebSocket connected');
+
+        // Configure session
+        const sessionConfig = {
+          type: 'session.update',
+          session: {
+            voice: 'Ara',
+            instructions: systemPrompt,
+            turn_detection: { type: 'server_vad' },
+            audio: {
+              input: { format: { type: 'audio/pcm', rate: 24000 } },
+              output: { format: { type: 'audio/pcm', rate: 24000 } },
+            },
+            tools: VOICE_TOOLS,
+          },
+        };
+        xaiWs.send(JSON.stringify(sessionConfig));
+      });
+
+      xaiWs.on('message', async (rawMsg) => {
+        let msg;
+        try {
+          msg = JSON.parse(rawMsg.toString());
+        } catch {
+          return;
+        }
+
+        switch (msg.type) {
+          case 'session.updated':
+            console.log('[voice-call] Session configured, ready');
+            socket.emit('voice-call-ready', { callId: callSession.id });
+            break;
+
+          case 'input_audio_buffer.speech_started':
+            socket.emit('voice-call-status', { status: 'user-speaking' });
+            break;
+
+          case 'input_audio_buffer.speech_stopped':
+            socket.emit('voice-call-status', { status: 'processing' });
+            break;
+
+          case 'conversation.item.input_audio_transcription.completed':
+            if (msg.transcript) {
+              callSession.transcript.push({ role: 'user', text: msg.transcript });
+              socket.emit('voice-call-user-transcript', { text: msg.transcript });
+            }
+            break;
+
+          case 'response.created':
+            callSession.currentResponseText = '';
+            callSession.currentResponseId = msg.response?.id || null;
+            socket.emit('voice-call-status', { status: 'speaking' });
+            break;
+
+          case 'response.output_audio.delta':
+            if (msg.delta) {
+              if (!callSession.suppressCurrentResponse) {
+                socket.emit('voice-call-audio-delta', { audio: msg.delta });
+              }
+            }
+            break;
+
+          case 'response.output_audio_transcript.delta':
+            if (msg.delta) {
+              callSession.currentResponseText += msg.delta;
+              // Once we have 50+ chars, check if this matches a previous response
+              if (!callSession.suppressCurrentResponse && callSession.currentResponseText.length >= 50) {
+                const prefix = callSession.currentResponseText.slice(0, 50);
+                if (callSession.completedResponseTexts.some(t => t.slice(0, 50) === prefix)) {
+                  callSession.suppressCurrentResponse = true;
+                  console.log('[voice-call] Suppressing duplicate response audio');
+                }
+              }
+              if (!callSession.suppressCurrentResponse) {
+                socket.emit('voice-call-transcript-delta', { text: msg.delta });
+              }
+            }
+            break;
+
+          case 'response.output_audio_transcript.done':
+            if (msg.transcript && !callSession.suppressCurrentResponse) {
+              callSession.transcript.push({ role: 'assistant', text: msg.transcript });
+            }
+            break;
+
+          case 'response.done': {
+            socket.emit('voice-call-status', { status: 'listening' });
+            const respText = callSession.currentResponseText;
+            if (respText && !callSession.suppressCurrentResponse) {
+              callSession.completedResponseTexts.push(respText);
+              // Keep only last 5 to prevent memory growth
+              if (callSession.completedResponseTexts.length > 5) {
+                callSession.completedResponseTexts.shift();
+              }
+              socket.emit('voice-call-response-done', { text: respText });
+            }
+            // Reset for next response
+            callSession.suppressCurrentResponse = false;
+            break;
+          }
+
+          case 'response.function_call_arguments.done': {
+            const { name: fnName, call_id, arguments: argsStr } = msg;
+            console.log(`[voice-call] Function call: ${fnName} (${call_id})`);
+            try {
+              const fnArgs = JSON.parse(argsStr || '{}');
+              const result = await executeTool(fnName, fnArgs);
+              xaiWs.send(JSON.stringify({
+                type: 'conversation.item.create',
+                item: {
+                  type: 'function_call_output',
+                  call_id: call_id,
+                  output: JSON.stringify(result),
+                },
+              }));
+              xaiWs.send(JSON.stringify({ type: 'response.create' }));
+            } catch (toolErr) {
+              console.error('[voice-call] Tool execution error:', toolErr);
+              xaiWs.send(JSON.stringify({
+                type: 'conversation.item.create',
+                item: {
+                  type: 'function_call_output',
+                  call_id: call_id,
+                  output: JSON.stringify({ success: false, message: toolErr.message }),
+                },
+              }));
+              xaiWs.send(JSON.stringify({ type: 'response.create' }));
+            }
+            break;
+          }
+
+          case 'error':
+            console.error('[voice-call] xAI error:', msg.error);
+            socket.emit('voice-call-error', { error: msg.error?.message || 'Voice service error' });
+            break;
+        }
+      });
+
+      xaiWs.on('error', (e) => {
+        console.error('[voice-call] xAI WebSocket error:', e.message);
+        socket.emit('voice-call-error', { error: 'Voice connection error' });
+      });
+
+      xaiWs.on('close', (code, reason) => {
+        console.log(`[voice-call] xAI WebSocket closed: ${code} ${reason}`);
+        if (activeCalls.has(socket.id)) {
+          socket.emit('voice-call-ended', { reason: 'Voice service disconnected' });
+        }
+      });
+    });
+
+    // Client sends PCM16 audio chunks as base64
+    socket.on('voice-call-audio-chunk', (data) => {
+      const session = activeCalls.get(socket.id);
+      if (!session || !session.xaiWs || session.xaiWs.readyState !== WebSocket.OPEN) return;
+
+      if (data?.audio) {
+        session.xaiWs.send(JSON.stringify({
+          type: 'input_audio_buffer.append',
+          audio: data.audio,
+        }));
+      }
+    });
+
+    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] Socket disconnected, cleaning up call');
+        cleanupCall(socket.id, session);
+      }
+    });
+  });
+
+  function cleanupCall(socketId, session) {
+    console.log(`[voice-call] Call ended (${session.transcript.length} turns)`);
+
+    // Close xAI WebSocket
+    if (session.xaiWs) {
+      try { session.xaiWs.close(); } catch {}
+    }
+
+    // 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_ara_${ts}.json`);
+
+        // Calculate duration in seconds
+        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: 'ara-voice-call',
+          timestamp: new Date().toISOString(),
+          duration: durationSeconds,
+          transcript: session.transcript,
+        };
+
+        fs.writeFileSync(pendingFile, JSON.stringify(logData, null, 2));
+        console.log(`[voice-call] Transcript saved: ${pendingFile}`);
+
+        // Fire wake hook to AIVA app
+        const relPath = `memory/call-logs/pending_ara_${ts}.json`;
+        const wakeText = `[VOICE-CALL-COMPLETE] Ara voice call ended. Duration: ${durationMin}m ${durationSec}s. Transcript saved to ${relPath}. Process action items.`;
+
+        fetch('http://localhost:3847/hooks/wake', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'x-aiva-internal': 'true',
+          },
+          body: JSON.stringify({ text: wakeText }),
+        }).catch(e => console.error('[voice-call] Failed to fire wake hook:', e.message));
+
+        // Also try OpenClaw wake hook as backup
+        fetch('http://localhost:18789/hooks/wake', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer aiva-hook-secret-2026' },
+          body: JSON.stringify({ text: wakeText, mode: 'now' }),
+        }).catch(e => console.error('[voice-call] OpenClaw wake hook failed:', e.message));
+      } catch (e) {
+        console.error('[voice-call] Failed to save transcript:', e.message);
+      }
+    }
+
+    activeCalls.delete(socketId);
+  }
+
+  console.log('[voice-call] Voice call handler initialized (xAI Voice Agent - Ara)');
+}
+
+module.exports = { setupVoiceCall };