mcp-voice-hooks 1.0.8 → 1.0.12

package/.claude/hooks/pre-speak-hook.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
 PORT="${MCP_VOICE_HOOKS_PORT:-5111}"
-curl -s -X POST http://localhost:${PORT}/api/hooks/pre-speak || echo '{"decision": "approve"}'
+curl -s -X POST http://localhost:${PORT}/api/hooks/pre-speak || echo '{"decision": "approve", "reason": "voice-hooks unavailable"}'

package/.claude/hooks/pre-tool-hook.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
 PORT="${MCP_VOICE_HOOKS_PORT:-5111}"
-curl -s -X POST http://localhost:${PORT}/api/hooks/pre-tool || echo '{"decision": "approve"}'
+curl -s -X POST http://localhost:${PORT}/api/hooks/pre-tool || echo '{"decision": "approve", "reason": "voice-hooks unavailable"}'

package/.claude/hooks/pre-wait-hook.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
 PORT="${MCP_VOICE_HOOKS_PORT:-5111}"
-curl -s -X POST http://localhost:${PORT}/api/hooks/pre-wait || echo '{"decision": "approve"}'
+curl -s -X POST http://localhost:${PORT}/api/hooks/pre-wait || echo '{"decision": "approve", "reason": "voice-hooks unavailable"}'

package/.claude/hooks/stop-hook.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
 PORT="${MCP_VOICE_HOOKS_PORT:-5111}"
-curl -s -X POST http://localhost:${PORT}/api/hooks/stop || echo '{"decision": "approve"}'
+curl -s -X POST http://localhost:${PORT}/api/hooks/stop || echo '{"decision": "approve", "reason": "voice-hooks unavailable"}'

package/CLAUDE.local.md

@@ -4,17 +4,10 @@
 # 1. Build the project first
 npm run build
 
-# 2. Update roadmap.md with version info and stage it
-git add roadmap.md
+# 2. Bump version (patch, minor, or major) - creates a commit and tag
+HUSKY=0 npm version patch --registry https://registry.npmjs.org/
 
-# 3. Bump version (patch, minor, or major) - creates a commit and tag
-npm version patch --registry https://registry.npmjs.org/
-
-# Alternative: Bump version without creating a commit/tag
-# npm version patch --no-git-tag-version
-# Then manually commit the changes
-
-# 4. Publish to npm (this creates the .tgz file automatically)
+# 3. Publish to npm (this creates the .tgz file automatically)
 npm publish --registry https://registry.npmjs.org/
 
 # Note: It can take 1-5 minutes for the package to be available globally

package/README.md

@@ -2,6 +2,10 @@
 
 Real-time voice interaction for Claude Code. Speak naturally while Claude works - interrupt, redirect, or provide continuous feedback without stopping.
 
+Optionally enable text-to-speech to have Claude speak back to you.
+
+Mac only for now.
+
 ## Demo
 
 [![Voice Hooks Demo](https://img.youtube.com/vi/KpkxvJ65gbM/0.jpg)](https://youtu.be/KpkxvJ65gbM)
@@ -15,11 +19,11 @@ mcp-voice-hooks enables continuous voice conversations with AI assistants by:
 - Using hooks to ensure Claude checks for voice input before tool use and before stopping
 - Allowing natural interruptions like "No, stop that" or "Wait, try something else"
 
-## Features
+## Browser Compatibility
 
-- 🎤 **Real-time Voice Capture**: Browser-based speech recognition with automatic segmentation
-- 🔄 **Continuous Interaction**: Keep talking while Claude works - no need to stop between commands
-- 🪝 **Smart Hook System**: Pre-tool and stop hooks ensure Claude always checks for your input
+- ✅ **Chrome**: Full support for speech recognition and text-to-speech
+- ✅ **Safari**: Full support for speech recognition and text-to-speech
+- ❌ **Edge**: Speech recognition not working on Apple Silicon (language-not-supported error)
 
 ## Installation in Your Own Project
 
@@ -52,21 +56,41 @@ mcp-voice-hooks enables continuous voice conversations with AI assistants by:
    claude
    ```
 
-3. **Open the voice interface** at <http://localhost:5111> and start speaking! 
+   **Important**: After the first-time installation, you will need to restart Claude for the hooks to take effect. This is because the hooks are automatically installed when the MCP server starts for the first time.
 
-   The hooks are automatically installed when the MCP server starts. You need to send one text message to Claude to trigger the voice hooks.
+3. **Open the voice interface** at <http://localhost:5111> and start speaking!
 
-   **Note**: After the first-time installation, you may need to restart Claude for the hooks to take effect.
+  You need to send one text message to Claude to trigger the voice hooks.
 
-   The default port is 5111. To use a different port, add to your project's `.claude/settings.json`:
+## Voice responses
 
-   ```json
-   {
-     "env": {
-       "MCP_VOICE_HOOKS_PORT": "8080"
-     }
-   }
-   ```
+There are two options for voice responses:
+
+1. Browser Text-to-Speech (Cloud)
+2. Browser Text-to-Speech (Local)
+3. Mac System Voice
+
+### Selecting and downloading high quality System Voices (Mac only)
+
+When "Mac System Voice" is selected, the system uses macOS's built-in `say` command.
+
+Configure the system voice in `System Settings > Accessibility > Spoken Content > System Voice`
+
+I recommend using a Siri voice, as they are much higher quality.
+
+Click the info icon next to the system voice dropdown. Search for "Siri" to find the highest quality voices. You'll have to trigger a download of the voice.
+
+It may take a while to download.
+
+Once it's downloaded, you can select it in the system voice dropdown.
+
+Test it with the bash command:
+
+```bash
+say "Hi, this is your mac system voice"
+```
+
+You can also download other high quality voices in the same way. Other voices will show up in the browser voice dropdown, but for Siri voices you need to set the system voice and select Mac System Voice in the browser voice dropdown.
 
 ## Manual Hook Installation
 
@@ -100,6 +124,10 @@ This will:
 - Clean up voice hooks from your project's `.claude/settings.json`
 - Preserve any custom hooks you've added
 
+## Known Limitations
+
+- **Intermittent Stop Hook Execution**: Claude Code's Stop hooks are not triggered consistently. Sometimes the assistant can end responses without the Stop hook being executed. I believe this is an issue with Claude Code's hook system, not with mcp-voice-hooks. When working correctly, the Stop hook should prevent the assistant from stopping without first checking for voice input.
+
 ## Development Mode
 
 If you're developing mcp-voice-hooks itself:
@@ -152,65 +180,14 @@ and then configure claude to use the mcp proxy like so:
 }
 ```
 
-## Voice responses (Mac only)
+### Port Configuration
 
-Add the post tool hook to your claude settings:
+The default port is 5111. To use a different port, add to your project's `.claude/settings.json`:
 
-```json
-{
+   ```json
    {
-     "hooks": {
-        "PostToolUse": [
-            {
-                "matcher": "^mcp__voice-hooks__",
-                "hooks": [
-                    {
-                        "type": "command",
-                        "command": "./.claude/hooks/post-tool-voice-hook.sh"
-                    }
-                ]
-            }
-        ]
-     },
      "env": {
-       "VOICE_RESPONSES_ENABLED": "true"
+       "MCP_VOICE_HOOKS_PORT": "8080"
      }
    }
-}
-```
-
-### Configuration
-
-Voice responses are disabled by default. To enable them:
-
-Add to your Claude Code settings JSON:
-
-```json
-{
-  "env": {
-    "VOICE_RESPONSES_ENABLED": "true"
-  }
-}
-```
-
-To disable voice responses, set the value to `false` or remove the setting entirely.
-
-### High quality voice responses
-
-These voice responses are spoken by your Mac's system voice.
-
-Configure in `System Settings > Accessibility > Spoken Content > System Voice`
-
-I recommend using a Siri voice, as they are much higher quality.
-
-Click the info icon next to the system voice dropdown. Search for "Siri" to find the highest quality voices. You'll have to trigger a download of the voice.
-
-It may take a while to download.
-
-Once it's downloaded, you can select it in the system voice dropdown.
-
-Test it with the bash command:
-
-```bash
-say "Hi, this is your mac system voice"
-```
+   ```

package/dist/unified-server.js

@@ -19,9 +19,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
-var DEFAULT_WAIT_TIMEOUT_SECONDS = 30;
-var MIN_WAIT_TIMEOUT_SECONDS = 30;
-var MAX_WAIT_TIMEOUT_SECONDS = 60;
+var WAIT_TIMEOUT_SECONDS = 60;
 var execAsync = promisify(exec);
 async function playNotificationSound() {
   try {
@@ -62,9 +60,10 @@ var UtteranceQueue = class {
 };
 var IS_MCP_MANAGED = process.argv.includes("--mcp-managed");
 var queue = new UtteranceQueue();
-var lastTimeoutTimestamp = null;
-var lastToolUseTimestamp = null;
-var lastSpeakTimestamp = null;
+var voicePreferences = {
+  voiceResponsesEnabled: false,
+  voiceInputActive: false
+};
 var app = express();
 app.use(cors());
 app.use(express.json());
@@ -99,7 +98,7 @@ app.get("/api/utterances", (req, res) => {
     }))
   });
 });
-app.get("/api/utterances/status", (req, res) => {
+app.get("/api/utterances/status", (_req, res) => {
   const total = queue.utterances.length;
   const pending = queue.utterances.filter((u) => u.status === "pending").length;
   const delivered = queue.utterances.filter((u) => u.status === "delivered").length;
@@ -110,6 +109,13 @@ app.get("/api/utterances/status", (req, res) => {
   });
 });
 app.post("/api/dequeue-utterances", (req, res) => {
+  if (!voicePreferences.voiceInputActive) {
+    res.status(400).json({
+      success: false,
+      error: "Voice input is not active. Cannot dequeue utterances when voice input is disabled."
+    });
+    return;
+  }
   const { limit = 10 } = req.body;
   const pendingUtterances = queue.utterances.filter((u) => u.status === "pending").sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime()).slice(0, limit);
   pendingUtterances.forEach((u) => {
@@ -124,36 +130,23 @@ app.post("/api/dequeue-utterances", (req, res) => {
   });
 });
 app.post("/api/wait-for-utterances", async (req, res) => {
-  const { seconds_to_wait = DEFAULT_WAIT_TIMEOUT_SECONDS } = req.body;
-  const secondsToWait = Math.max(
-    MIN_WAIT_TIMEOUT_SECONDS,
-    Math.min(MAX_WAIT_TIMEOUT_SECONDS, seconds_to_wait)
-  );
+  if (!voicePreferences.voiceInputActive) {
+    res.status(400).json({
+      success: false,
+      error: "Voice input is not active. Cannot wait for utterances when voice input is disabled."
+    });
+    return;
+  }
+  const secondsToWait = WAIT_TIMEOUT_SECONDS;
   const maxWaitMs = secondsToWait * 1e3;
   const startTime = Date.now();
   debugLog(`[Server] Starting wait_for_utterance (${secondsToWait}s)`);
-  if (lastTimeoutTimestamp) {
-    const hasNewUtterances = queue.utterances.some(
-      (u) => u.timestamp > lastTimeoutTimestamp
-    );
-    if (!hasNewUtterances) {
-      debugLog("[Server] No new utterances since last timeout, returning immediately");
-      res.json({
-        success: true,
-        utterances: [],
-        message: `No utterances found after waiting ${secondsToWait} seconds.`,
-        waitTime: 0
-      });
-      return;
-    }
-  }
   let firstTime = true;
   while (Date.now() - startTime < maxWaitMs) {
     const pendingUtterances = queue.utterances.filter(
-      (u) => u.status === "pending" && (!lastTimeoutTimestamp || u.timestamp > lastTimeoutTimestamp)
+      (u) => u.status === "pending"
     );
     if (pendingUtterances.length > 0) {
-      lastTimeoutTimestamp = null;
       const sortedUtterances = pendingUtterances.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
       sortedUtterances.forEach((u) => {
         queue.markDelivered(u.id);
@@ -178,7 +171,6 @@ app.post("/api/wait-for-utterances", async (req, res) => {
     }
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
-  lastTimeoutTimestamp = /* @__PURE__ */ new Date();
   res.json({
     success: true,
     utterances: [],
@@ -186,11 +178,7 @@ app.post("/api/wait-for-utterances", async (req, res) => {
     waitTime: maxWaitMs
   });
 });
-app.get("/api/should-wait", (req, res) => {
-  const shouldWait = !lastTimeoutTimestamp || queue.utterances.some((u) => u.timestamp > lastTimeoutTimestamp);
-  res.json({ shouldWait });
-});
-app.get("/api/has-pending-utterances", (req, res) => {
+app.get("/api/has-pending-utterances", (_req, res) => {
   const pendingCount = queue.utterances.filter((u) => u.status === "pending").length;
   const hasPending = pendingCount > 0;
   res.json({
@@ -200,19 +188,21 @@ app.get("/api/has-pending-utterances", (req, res) => {
 });
 app.post("/api/validate-action", (req, res) => {
   const { action } = req.body;
-  const voiceResponsesEnabled = process.env.VOICE_RESPONSES_ENABLED === "true";
+  const voiceResponsesEnabled = voicePreferences.voiceResponsesEnabled;
   if (!action || !["tool-use", "stop"].includes(action)) {
     res.status(400).json({ error: 'Invalid action. Must be "tool-use" or "stop"' });
     return;
   }
-  const pendingUtterances = queue.utterances.filter((u) => u.status === "pending");
-  if (pendingUtterances.length > 0) {
-    res.json({
-      allowed: false,
-      requiredAction: "dequeue_utterances",
-      reason: `${pendingUtterances.length} pending utterance(s) must be dequeued first. Please use dequeue_utterances to process them.`
-    });
-    return;
+  if (voicePreferences.voiceInputActive) {
+    const pendingUtterances = queue.utterances.filter((u) => u.status === "pending");
+    if (pendingUtterances.length > 0) {
+      res.json({
+        allowed: false,
+        requiredAction: "dequeue_utterances",
+        reason: `${pendingUtterances.length} pending utterance(s) must be dequeued first. Please use dequeue_utterances to process them.`
+      });
+      return;
+    }
   }
   if (voiceResponsesEnabled) {
     const deliveredUtterances = queue.utterances.filter((u) => u.status === "delivered");
@@ -225,9 +215,8 @@ app.post("/api/validate-action", (req, res) => {
       return;
     }
   }
-  if (action === "stop") {
-    const shouldWait = !lastTimeoutTimestamp || queue.utterances.some((u) => u.timestamp > lastTimeoutTimestamp);
-    if (shouldWait) {
+  if (action === "stop" && voicePreferences.voiceInputActive) {
+    if (queue.utterances.length > 0) {
       res.json({
         allowed: false,
         requiredAction: "wait_for_utterance",
@@ -241,13 +230,16 @@ app.post("/api/validate-action", (req, res) => {
   });
 });
 function handleHookRequest(attemptedAction) {
-  const voiceResponsesEnabled = process.env.VOICE_RESPONSES_ENABLED === "true";
-  const pendingUtterances = queue.utterances.filter((u) => u.status === "pending");
-  if (pendingUtterances.length > 0) {
-    return {
-      decision: "block",
-      reason: `${pendingUtterances.length} pending utterance(s) must be dequeued first. Please use dequeue_utterances to process them.`
-    };
+  const voiceResponsesEnabled = voicePreferences.voiceResponsesEnabled;
+  const voiceInputActive = voicePreferences.voiceInputActive;
+  if (voiceInputActive) {
+    const pendingUtterances = queue.utterances.filter((u) => u.status === "pending");
+    if (pendingUtterances.length > 0) {
+      return {
+        decision: "block",
+        reason: `${pendingUtterances.length} pending utterance(s) must be dequeued first. Please use dequeue_utterances to process them.`
+      };
+    }
   }
   if (voiceResponsesEnabled) {
     const deliveredUtterances = queue.utterances.filter((u) => u.status === "delivered");
@@ -262,33 +254,19 @@ function handleHookRequest(attemptedAction) {
     }
   }
   if (attemptedAction === "tool") {
-    lastToolUseTimestamp = /* @__PURE__ */ new Date();
     return { decision: "approve" };
   }
   if (attemptedAction === "wait") {
-    if (voiceResponsesEnabled && lastToolUseTimestamp && (!lastSpeakTimestamp || lastSpeakTimestamp < lastToolUseTimestamp)) {
-      return {
-        decision: "block",
-        reason: "Assistant must speak after using tools. Please use the speak tool to respond before waiting for utterances."
-      };
-    }
     return { decision: "approve" };
   }
   if (attemptedAction === "speak") {
     return { decision: "approve" };
   }
   if (attemptedAction === "stop") {
-    if (voiceResponsesEnabled && lastToolUseTimestamp && (!lastSpeakTimestamp || lastSpeakTimestamp < lastToolUseTimestamp)) {
-      return {
-        decision: "block",
-        reason: "Assistant must speak after using tools. Please use the speak tool to respond before proceeding."
-      };
-    }
-    const shouldWait = !lastTimeoutTimestamp || queue.utterances.some((u) => u.timestamp > lastTimeoutTimestamp);
-    if (shouldWait) {
+    if (voiceInputActive) {
       return {
         decision: "block",
-        reason: "Assistant tried to end its response. Stopping is not allowed without first checking for voice input. Assistant should now use wait_for_utterance to check for voice input"
+        reason: "Assistant tried to end its response, but voice input is active. Stopping is not allowed without first checking for voice input. Assistant should now use wait_for_utterance to check for voice input"
       };
     }
     return {
@@ -314,7 +292,7 @@ app.post("/api/hooks/pre-wait", (_req, res) => {
   const result = handleHookRequest("wait");
   res.json(result);
 });
-app.delete("/api/utterances", (req, res) => {
+app.delete("/api/utterances", (_req, res) => {
   const clearedCount = queue.utterances.length;
   queue.clear();
   res.json({
@@ -323,21 +301,67 @@ app.delete("/api/utterances", (req, res) => {
     clearedCount
   });
 });
+var ttsClients = /* @__PURE__ */ new Set();
+app.get("/api/tts-events", (_req, res) => {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive"
+  });
+  res.write('data: {"type":"connected"}\n\n');
+  ttsClients.add(res);
+  res.on("close", () => {
+    ttsClients.delete(res);
+  });
+});
+function notifyTTSClients(text) {
+  const message = JSON.stringify({ type: "speak", text });
+  ttsClients.forEach((client) => {
+    client.write(`data: ${message}
+
+`);
+  });
+}
+app.post("/api/voice-preferences", (req, res) => {
+  const { voiceResponsesEnabled } = req.body;
+  voicePreferences.voiceResponsesEnabled = !!voiceResponsesEnabled;
+  debugLog(`[Preferences] Updated: voiceResponses=${voicePreferences.voiceResponsesEnabled}`);
+  res.json({
+    success: true,
+    preferences: voicePreferences
+  });
+});
+app.post("/api/voice-input-state", (req, res) => {
+  const { active } = req.body;
+  voicePreferences.voiceInputActive = !!active;
+  debugLog(`[Voice Input] ${voicePreferences.voiceInputActive ? "Started" : "Stopped"} listening`);
+  res.json({
+    success: true,
+    voiceInputActive: voicePreferences.voiceInputActive
+  });
+});
 app.post("/api/speak", async (req, res) => {
   const { text } = req.body;
   if (!text || !text.trim()) {
     res.status(400).json({ error: "Text is required" });
     return;
   }
+  if (!voicePreferences.voiceResponsesEnabled) {
+    debugLog(`[Speak] Voice responses disabled, returning error`);
+    res.status(400).json({
+      error: "Voice responses are disabled",
+      message: "Cannot speak when voice responses are disabled"
+    });
+    return;
+  }
   try {
-    await execAsync(`say -r 350 "${text.replace(/"/g, '\\"')}"`);
-    debugLog(`[Speak] Spoke text: "${text}"`);
+    notifyTTSClients(text);
+    debugLog(`[Speak] Sent text to browser for TTS: "${text}"`);
     const deliveredUtterances = queue.utterances.filter((u) => u.status === "delivered");
     deliveredUtterances.forEach((u) => {
       u.status = "responded";
       debugLog(`[Queue] marked as responded: "${u.text}"	[id: ${u.id}]`);
     });
-    lastSpeakTimestamp = /* @__PURE__ */ new Date();
     res.json({
       success: true,
       message: "Text spoken successfully",
@@ -351,6 +375,27 @@ app.post("/api/speak", async (req, res) => {
     });
   }
 });
+app.post("/api/speak-system", async (req, res) => {
+  const { text, rate = 150 } = req.body;
+  if (!text || !text.trim()) {
+    res.status(400).json({ error: "Text is required" });
+    return;
+  }
+  try {
+    await execAsync(`say -r ${rate} "${text.replace(/"/g, '\\"')}"`);
+    debugLog(`[Speak System] Spoke text using macOS say: "${text}" (rate: ${rate})`);
+    res.json({
+      success: true,
+      message: "Text spoken successfully via system voice"
+    });
+  } catch (error) {
+    debugLog(`[Speak System] Failed to speak text: ${error}`);
+    res.status(500).json({
+      error: "Failed to speak text via system voice",
+      details: error instanceof Error ? error.message : String(error)
+    });
+  }
+});
 app.get("/", (_req, res) => {
   res.sendFile(path.join(__dirname, "..", "public", "index.html"));
 });
@@ -360,7 +405,7 @@ app.listen(HTTP_PORT, () => {
   console.log(`[Mode] Running in ${IS_MCP_MANAGED ? "MCP-managed" : "standalone"} mode`);
 });
 function getVoiceResponseReminder() {
-  const voiceResponsesEnabled = process.env.VOICE_RESPONSES_ENABLED === "true";
+  const voiceResponsesEnabled = voicePreferences.voiceResponsesEnabled;
   return voiceResponsesEnabled ? "\n\nThe user has enabled voice responses, so use the 'speak' tool to respond to the user's voice input before proceeding." : "";
 }
 if (IS_MCP_MANAGED) {
@@ -395,18 +440,10 @@ if (IS_MCP_MANAGED) {
         },
         {
           name: "wait_for_utterance",
-          description: "Wait for an utterance to be available or until timeout. Returns immediately if no utterances since last timeout.",
+          description: "Wait for an utterance to be available or until timeout",
           inputSchema: {
             type: "object",
-            properties: {
-              seconds_to_wait: {
-                type: "number",
-                description: `Maximum seconds to wait for an utterance (default: ${DEFAULT_WAIT_TIMEOUT_SECONDS}, min: ${MIN_WAIT_TIMEOUT_SECONDS}, max: ${MAX_WAIT_TIMEOUT_SECONDS})`,
-                default: DEFAULT_WAIT_TIMEOUT_SECONDS,
-                minimum: MIN_WAIT_TIMEOUT_SECONDS,
-                maximum: MAX_WAIT_TIMEOUT_SECONDS
-              }
-            }
+            properties: {}
           }
         },
         {
@@ -437,6 +474,16 @@ if (IS_MCP_MANAGED) {
           body: JSON.stringify({ limit })
         });
         const data = await response.json();
+        if (!response.ok) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: ${data.error || "Failed to dequeue utterances"}`
+              }
+            ]
+          };
+        }
         if (data.utterances.length === 0) {
           return {
             content: [
@@ -459,18 +506,23 @@ ${data.utterances.reverse().map((u) => `"${u.text}"	[time: ${new Date(u.timestam
         };
       }
       if (name === "wait_for_utterance") {
-        const requestedSeconds = args?.seconds_to_wait ?? DEFAULT_WAIT_TIMEOUT_SECONDS;
-        const secondsToWait = Math.max(
-          MIN_WAIT_TIMEOUT_SECONDS,
-          Math.min(MAX_WAIT_TIMEOUT_SECONDS, requestedSeconds)
-        );
-        debugLog(`[MCP] Calling wait_for_utterance with ${secondsToWait}s timeout`);
+        debugLog(`[MCP] Calling wait_for_utterance`);
         const response = await fetch(`http://localhost:${HTTP_PORT}/api/wait-for-utterances`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ seconds_to_wait: secondsToWait })
+          body: JSON.stringify({})
         });
         const data = await response.json();
+        if (!response.ok) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: ${data.error || "Failed to wait for utterances"}`
+              }
+            ]
+          };
+        }
         if (data.utterances && data.utterances.length > 0) {
           const utteranceTexts = data.utterances.map((u) => `[${u.timestamp}] "${u.text}"`).join("\n");
           return {
@@ -488,7 +540,7 @@ ${utteranceTexts}${getVoiceResponseReminder()}`
             content: [
               {
                 type: "text",
-                text: data.message || `No utterances found after waiting ${secondsToWait} seconds.`
+                text: data.message || `No utterances found. Timed out.`
               }
             ]
           };
@@ -518,8 +570,8 @@ ${utteranceTexts}${getVoiceResponseReminder()}`
             content: [
               {
                 type: "text",
-                text: `Spoke: "${text}"
-${data.respondedCount > 0 ? `Marked ${data.respondedCount} utterance(s) as responded.` : "No delivered utterances to mark as responded."}`
+                text: ""
+                // Return empty string for success
               }
             ]
           };