@lawpath-tech/openclaw 2026.2.21-19 → 2026.2.21-20

package/extensions/voice-call/src/providers/twilio.ts

@@ -565,30 +565,48 @@ export class TwilioProvider implements VoiceCallProvider {
       throw new Error("TTS provider and media stream handler required");
     }
 
-    // Stream audio in 20ms chunks (160 bytes at 8kHz mu-law)
-    const CHUNK_SIZE = 160;
+    const CHUNK_SIZE = 160; // 20ms at 8kHz mu-law
     const CHUNK_DELAY_MS = 20;
-
     const handler = this.mediaStreamHandler;
     const ttsProvider = this.ttsProvider;
+
     await handler.queueTts(streamSid, async (signal) => {
-      // Generate audio with core TTS (returns mu-law at 8kHz)
+      // Try streaming TTS first (sends audio as chunks arrive from API)
+      if (ttsProvider.synthesizeForTelephonyStream) {
+        try {
+          let framesEmitted = 0;
+          const stream = ttsProvider.synthesizeForTelephonyStream(text);
+          for await (const muLawChunk of stream) {
+            if (signal.aborted) break;
+            for (const chunk of chunkAudio(muLawChunk, CHUNK_SIZE)) {
+              if (signal.aborted) break;
+              handler.sendAudio(streamSid, chunk);
+              framesEmitted++;
+              await new Promise((resolve) => setTimeout(resolve, CHUNK_DELAY_MS));
+            }
+          }
+          if (!signal.aborted && framesEmitted > 0) {
+            handler.sendMark(streamSid, `tts-${Date.now()}`);
+          }
+          return;
+        } catch (err) {
+          console.warn(
+            `[voice-call] Streaming TTS failed, falling back to buffered:`,
+            err instanceof Error ? err.message : err,
+          );
+        }
+      }
+
+      // Fallback: buffered TTS (full audio generated before sending)
       const muLawAudio = await ttsProvider.synthesizeForTelephony(text);
       for (const chunk of chunkAudio(muLawAudio, CHUNK_SIZE)) {
-        if (signal.aborted) {
-          break;
-        }
+        if (signal.aborted) break;
         handler.sendAudio(streamSid, chunk);
-
-        // Pace the audio to match real-time playback
         await new Promise((resolve) => setTimeout(resolve, CHUNK_DELAY_MS));
-        if (signal.aborted) {
-          break;
-        }
+        if (signal.aborted) break;
       }
 
       if (!signal.aborted) {
-        // Send a mark to track when audio finishes
         handler.sendMark(streamSid, `tts-${Date.now()}`);
       }
     });

package/extensions/voice-call/src/response-generator.ts

@@ -59,9 +59,9 @@ export async function generateVoiceResponse(
   }
   const cfg = coreConfig;
 
-  // Build voice-specific session key based on phone number
-  const normalizedPhone = from.replace(/\D/g, "");
-  const sessionKey = `voice:${normalizedPhone}`;
+  // Build voice-specific session key per call (not per phone number)
+  // so conversation history doesn't leak between separate calls
+  const sessionKey = `voice:${callId}`;
   const agentId = "main";
 
   // Resolve paths

package/extensions/voice-call/src/telephony-audio.ts

@@ -67,6 +67,60 @@ export function chunkAudio(audio: Buffer, chunkSize = 160): Generator<Buffer, vo
   })();
 }
 
+/**
+ * Stateful incremental PCM-to-mulaw converter for streaming.
+ * Handles odd-byte chunk boundaries between calls.
+ */
+export type PcmToMulawStreamState = {
+  oddByte: number | null;
+  srcPosCarry: number;
+};
+
+export function createPcmToMulawStreamState(): PcmToMulawStreamState {
+  return { oddByte: null, srcPosCarry: 0 };
+}
+
+export function convertPcmChunkToMulaw8k(
+  chunk: Buffer,
+  inputSampleRate: number,
+  state: PcmToMulawStreamState,
+): Buffer {
+  let data = chunk;
+  if (state.oddByte !== null) {
+    data = Buffer.concat([Buffer.from([state.oddByte]), chunk]);
+    state.oddByte = null;
+  }
+  if (data.length % 2 !== 0) {
+    state.oddByte = data[data.length - 1]!;
+    data = data.subarray(0, data.length - 1);
+  }
+
+  if (data.length === 0) return Buffer.alloc(0);
+
+  const inputSamples = data.length / 2;
+  const ratio = inputSampleRate / TELEPHONY_SAMPLE_RATE;
+  const outputSamples: number[] = [];
+
+  let srcPos = state.srcPosCarry;
+  while (srcPos < inputSamples) {
+    const srcIndex = Math.floor(srcPos);
+    const frac = srcPos - srcIndex;
+    const s0 = data.readInt16LE(srcIndex * 2);
+    const s1Index = Math.min(srcIndex + 1, inputSamples - 1);
+    const s1 = data.readInt16LE(s1Index * 2);
+    const sample = Math.round(s0 + frac * (s1 - s0));
+    outputSamples.push(linearToMulaw(clamp16(sample)));
+    srcPos += ratio;
+  }
+  state.srcPosCarry = srcPos - inputSamples;
+
+  const output = Buffer.alloc(outputSamples.length);
+  for (let i = 0; i < outputSamples.length; i++) {
+    output[i] = outputSamples[i]!;
+  }
+  return output;
+}
+
 function linearToMulaw(sample: number): number {
   const BIAS = 132;
   const CLIP = 32635;

package/extensions/voice-call/src/telephony-tts.ts

@@ -1,6 +1,11 @@
+import type { Readable } from "node:stream";
 import type { VoiceCallTtsConfig } from "./config.js";
 import type { CoreConfig } from "./core-bridge.js";
-import { convertPcmToMulaw8k } from "./telephony-audio.js";
+import {
+  convertPcmToMulaw8k,
+  convertPcmChunkToMulaw8k,
+  createPcmToMulawStreamState,
+} from "./telephony-audio.js";
 
 export type TelephonyTtsRuntime = {
   textToSpeechTelephony: (params: {
@@ -14,10 +19,18 @@ export type TelephonyTtsRuntime = {
     provider?: string;
     error?: string;
   }>;
+  textToSpeechTelephonyStream?: (params: { text: string; cfg: CoreConfig }) => Promise<{
+    success: boolean;
+    stream?: ReadableStream<Uint8Array>;
+    sampleRate?: number;
+    cleanup?: () => void;
+    error?: string;
+  }>;
 };
 
 export type TelephonyTtsProvider = {
   synthesizeForTelephony: (text: string) => Promise<Buffer>;
+  synthesizeForTelephonyStream?: (text: string) => AsyncGenerator<Buffer, void, unknown>;
 };
 
 const BLOCKED_MERGE_KEYS = new Set(["__proto__", "prototype", "constructor"]);
@@ -30,7 +43,7 @@ export function createTelephonyTtsProvider(params: {
   const { coreConfig, ttsOverride, runtime } = params;
   const mergedConfig = applyTtsOverride(coreConfig, ttsOverride);
 
-  return {
+  const provider: TelephonyTtsProvider = {
     synthesizeForTelephony: async (text: string) => {
       const result = await runtime.textToSpeechTelephony({
         text,
@@ -44,6 +57,31 @@ export function createTelephonyTtsProvider(params: {
       return convertPcmToMulaw8k(result.audioBuffer, result.sampleRate);
     },
   };
+
+  if (runtime.textToSpeechTelephonyStream) {
+    const streamFn = runtime.textToSpeechTelephonyStream;
+    provider.synthesizeForTelephonyStream = async function* (text: string) {
+      const result = await streamFn({ text, cfg: mergedConfig });
+      if (!result.success || !result.stream || !result.sampleRate) {
+        throw new Error(result.error ?? "TTS streaming failed");
+      }
+      const state = createPcmToMulawStreamState();
+      const reader = result.stream.getReader();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          const mulaw = convertPcmChunkToMulaw8k(Buffer.from(value), result.sampleRate, state);
+          if (mulaw.length > 0) yield mulaw;
+        }
+      } finally {
+        reader.releaseLock();
+        result.cleanup?.();
+      }
+    };
+  }
+
+  return provider;
 }
 
 function applyTtsOverride(coreConfig: CoreConfig, override?: VoiceCallTtsConfig): CoreConfig {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lawpath-tech/openclaw",
-  "version": "2026.2.21-19",
+  "version": "2026.2.21-20",
   "description": "Multi-channel AI gateway with extensible messaging integrations",
   "keywords": [],
   "homepage": "https://github.com/openclaw/openclaw#readme",