@inetafrica/open-claudia 2.6.49 → 2.6.50

package/core/runner.js

@@ -315,6 +315,15 @@ async function buildClaudeArgs(prompt, opts = {}) {
   if (settings.permissionMode) args.push("--permission-mode", settings.permissionMode);
   else args.push("--dangerously-skip-permissions");
   if (settings.worktree) args.push("--worktree");
+  // Voice turns stream partial text so the spoken reply can start mid-generation
+  // (see the streaming-out handler in the runner). Strictly gated to the voice
+  // channel — zero behaviour change for Telegram/Kazee.
+  if (state.lastInputWasVoice) {
+    try {
+      const { currentTransport } = require("./context");
+      if (currentTransport() === "voice") args.push("--include-partial-messages");
+    } catch { /* context not ready — skip streaming flag */ }
+  }
   // Dynamic state rides in the user prompt so the appended system prompt
   // stays byte-stable across turns and the prompt-cache prefix survives.
   args.push(await promptWithDynamicContext(prompt));
@@ -814,6 +823,50 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   state.statusMessageId = null;
   state.streamBuffer = "";
   let assistantText = "";
+
+  // Voice streaming-out: on voice turns we speak each finished sentence as it is
+  // generated (off the partial text_delta events) so the first audio plays while
+  // the rest of the reply is still being written — far lower time-to-first-sound
+  // than synthesizing one pass over the whole reply at the end. Reads the delta
+  // stream only; the text/transcript channel still reads whole-message events, so
+  // chat transports are completely unaffected.
+  let voiceStreaming = false;
+  try {
+    const { currentTransport } = require("./context");
+    voiceStreaming = !!state.lastInputWasVoice && currentTransport() === "voice";
+  } catch { voiceStreaming = false; }
+  let spokenBuf = "";                 // text_delta accumulator awaiting a sentence boundary
+  let ttsChain = Promise.resolve();   // ordered send queue so clips play in order
+  let spokeAnyStreamed = false;
+  const SPOKEN_MIN_CHARS = 40;        // don't fire TTS on tiny fragments ("Hi.")
+  function dispatchSpoken(text) {
+    const clean = redactSensitive(text);
+    if (!clean.trim()) return;
+    spokeAnyStreamed = true;
+    const synthP = synthSentenceMp3(clean); // start synth now (parallel)
+    ttsChain = ttsChain.then(async () => {  // but send strictly in order
+      try { const clip = await synthP; if (clip) await sendVoice(clip); }
+      catch (e) { console.error("voice stream clip failed:", e.message); }
+    });
+  }
+  function pumpSpoken(flush) {
+    // Cut the smallest prefix that ends in a sentence terminator and is at least
+    // SPOKEN_MIN_CHARS long, dispatch it, repeat. On flush, send whatever remains.
+    while (true) {
+      const re = /[.!?]+(?=\s|$)/g;
+      let idx = -1, m;
+      while ((m = re.exec(spokenBuf)) !== null) {
+        const end = m.index + m[0].length;
+        if (end >= SPOKEN_MIN_CHARS) { idx = end; break; }
+      }
+      if (idx === -1) break;
+      const sentence = spokenBuf.slice(0, idx).trim();
+      spokenBuf = spokenBuf.slice(idx).replace(/^\s+/, "");
+      if (sentence) dispatchSpoken(sentence);
+    }
+    if (flush) { const tail = spokenBuf.trim(); spokenBuf = ""; if (tail) dispatchSpoken(tail); }
+  }
+
   let toolUses = [];
   let currentTool = null;
   let currentToolDetail = "";
@@ -1020,6 +1073,15 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     const lastNewline = state.streamBuffer.lastIndexOf("\n");
     state.streamBuffer = lastNewline >= 0 ? state.streamBuffer.slice(lastNewline + 1) : state.streamBuffer;
     for (const evt of events) {
+      // Voice streaming-out: speak finished sentences as the model writes them.
+      // Only text_delta is spoken; thinking_delta and tool events are ignored.
+      if (voiceStreaming && evt.type === "stream_event"
+          && evt.event?.type === "content_block_delta"
+          && evt.event.delta?.type === "text_delta"
+          && typeof evt.event.delta.text === "string") {
+        spokenBuf += evt.event.delta.text;
+        pumpSpoken(false);
+      }
       if (evt.type === "assistant" && evt.message?.usage) {
         const callPrefix = usageParts(evt.message.usage, settings.backend || "claude").context;
         if (callPrefix > peakContextTokens) peakContextTokens = callPrefix;
@@ -1212,25 +1274,37 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
 
       if (state.lastInputWasVoice) {
         state.lastInputWasVoice = false;
-        // Spoken replies belong to the hands-free voice channel. On chat
-        // transports (Telegram/Kazee) an auto voice note on every voice
-        // input is unwanted noise, so gate it to the voice channel.
-        const { currentTransport } = require("./context");
-        if (currentTransport() === "voice") {
-          // Stream the spoken reply sentence-by-sentence so the first audio
-          // plays while the rest still synthesizes — far lower time-to-first-
-          // sound than waiting for one TTS pass over the whole reply.
-          const sentences = splitSentences(finalText);
-          let spokeAny = false;
-          for (const sentence of sentences) {
-            const clip = await synthSentenceMp3(sentence);
-            if (clip) { spokeAny = true; await sendVoice(clip); }
-          }
-          if (!spokeAny) {
+        if (voiceStreaming) {
+          // Sentences were already being spoken as the model wrote them. Flush
+          // the trailing partial sentence, wait for the ordered send queue to
+          // drain, then close the turn so the client re-arms the mic.
+          pumpSpoken(true);
+          await ttsChain;
+          if (!spokeAnyStreamed) {
+            // Tool-only / empty turn produced no spoken text — say the final
+            // text once so the user still hears a reply.
             const voicePath = await textToVoice(finalText);
             if (voicePath) await sendVoice(voicePath);
           }
           await sendVoiceEnd();
+        } else {
+          // Non-streamed fallback. Spoken replies belong to the hands-free voice
+          // channel; on chat transports (Telegram/Kazee) an auto voice note on
+          // every voice input is unwanted noise, so gate it to the voice channel.
+          const { currentTransport } = require("./context");
+          if (currentTransport() === "voice") {
+            const sentences = splitSentences(finalText);
+            let spokeAny = false;
+            for (const sentence of sentences) {
+              const clip = await synthSentenceMp3(sentence);
+              if (clip) { spokeAny = true; await sendVoice(clip); }
+            }
+            if (!spokeAny) {
+              const voicePath = await textToVoice(finalText);
+              if (voicePath) await sendVoice(voicePath);
+            }
+            await sendVoiceEnd();
+          }
         }
       }
     } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.49",
+  "version": "2.6.50",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {