@inetafrica/open-claudia 3.1.12 → 3.1.13

package/.env.example

@@ -13,6 +13,8 @@ KAZEE_BOT_USER_ID=
 KAZEE_OWNER_USER_ID=
 # Set to 1 to log every inbound Kazee socket event (debug aid; noisy).
 KAZEE_DEBUG_EVENTS=
+# Optional override; Kazee calls default to the production Janus WebSocket.
+KAZEE_JANUS_URL=wss://janus.kazee.africa/ws
 
 WORKSPACE=/path/to/your/workspace
 # Both provider paths are optional. Leave blank to discover the CLI on PATH.

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## v3.1.13 — Owner-only Kazee calls reach Open Claudia
+
+- Accepts incoming audio calls from the configured Kazee owner only; external, video, malformed, and concurrent calls are rejected before any media session is created.
+- Joins the existing Janus VideoRoom as a headless publisher/subscriber using pure-TypeScript WebRTC, decodes inbound Opus, commits VAD-delimited 16 kHz PCM to hosted streaming STT, and routes final utterances through the owner's normal Kazee identity and conversation.
+- Speaks only the settled, guardrail-vetted answer through hosted Pocket TTS PCM and Opus RTP. Provider narration and transient progress previews are suppressed in calls; audio is never persisted.
+- Adds deterministic audio, Janus transaction, WebRTC RTP, speech framing, owner gate, lifecycle, and AI-routing tests. Updates `ws` to the patched 8.21 line across direct and Socket.IO use.
+
 ## v3.1.10 — `say` synthesizes in the bot process, not the stripped subprocess
 
 - v3.1.9 carried this exact fix but its build never published: the version pin in `test-provider-language.js` still read `3.1.8`, so the guard failed and the docker stage was skipped. Re-cut as v3.1.10 per "never retag a failed version."

package/channels/kazee/adapter.js

@@ -13,6 +13,7 @@ const { canonicalForChannel } = require("../../core/identity");
 const { inlineKeyboardToPortable } = require("../types");
 const { createKazeeSocket } = require("./socket");
 const { normalize } = require("./format");
+const { KazeeCallManager } = require("./call/manager");
 
 class KazeeAdapter {
   constructor({ id = "kazee", url, token, ownerUserId, botUserId }) {
@@ -27,6 +28,7 @@ class KazeeAdapter {
     this.botUserId = botUserId || null;
     this._listeners = { message: new Set(), action: new Set() };
     this._socket = null;
+    this._callManager = new KazeeCallManager({ adapter: this });
   }
 
   on(event, fn) {
@@ -67,11 +69,13 @@ class KazeeAdapter {
   }
 
   async stop() {
+    await this._callManager.stop();
     try { this._socket?.disconnect?.(); } catch (e) {}
     this._socket = null;
   }
 
   _wireSocket(socket) {
+    this._callManager.wire(socket);
     if (process.env.KAZEE_DEBUG_EVENTS) {
       socket.onAny((event, ...args) => {
         try { console.log(`[kazee event] ${event}`, JSON.stringify(args).slice(0, 400)); }

package/channels/kazee/call/audio.js

@@ -0,0 +1,133 @@
+"use strict";
+
+const OpusScript = require("opusscript");
+
+const WEBRTC_RATE = 48000;
+const STT_RATE = 16000;
+const FRAME_MS = 20;
+const WEBRTC_SAMPLES = WEBRTC_RATE * FRAME_MS / 1000;
+
+class OpusAudioCodec {
+  constructor({ channels = 1 } = {}) {
+    this.channels = channels;
+    this.encoder = new OpusScript(WEBRTC_RATE, channels, OpusScript.Application.VOIP);
+    this.decoder = new OpusScript(WEBRTC_RATE, channels, OpusScript.Application.VOIP);
+  }
+
+  encode(pcm48k) {
+    if (!Buffer.isBuffer(pcm48k)) pcm48k = Buffer.from(pcm48k);
+    const samples = pcm48k.length / 2 / this.channels;
+    if (samples !== WEBRTC_SAMPLES) {
+      throw new Error(`Opus input must be exactly ${WEBRTC_SAMPLES} samples per channel (20ms)`);
+    }
+    return Buffer.from(this.encoder.encode(pcm48k, samples));
+  }
+
+  decode(opus) {
+    return Buffer.from(this.decoder.decode(Buffer.from(opus)));
+  }
+
+  close() {
+    this.encoder?.delete();
+    this.decoder?.delete();
+    this.encoder = null;
+    this.decoder = null;
+  }
+}
+
+// WebRTC Opus is 48 kHz. Faster Whisper's streaming endpoint accepts PCM at
+// any declared rate, but 16 kHz cuts bandwidth and inference conversion work.
+function downsample48To16(pcm48k) {
+  if (!Buffer.isBuffer(pcm48k)) pcm48k = Buffer.from(pcm48k);
+  const input = new Int16Array(pcm48k.buffer, pcm48k.byteOffset, Math.floor(pcm48k.length / 2));
+  const output = Buffer.allocUnsafe(Math.floor(input.length / 3) * 2);
+  const samples = new Int16Array(output.buffer, output.byteOffset, output.length / 2);
+  for (let i = 0, j = 0; j < samples.length; i += 3, j += 1) {
+    samples[j] = Math.round((input[i] + input[i + 1] + input[i + 2]) / 3);
+  }
+  return output;
+}
+
+function upsampleTo48(pcm, sourceRate) {
+  if (!Buffer.isBuffer(pcm)) pcm = Buffer.from(pcm);
+  if (sourceRate === WEBRTC_RATE) return Buffer.from(pcm);
+  if (!Number.isFinite(sourceRate) || sourceRate < 8000 || sourceRate > WEBRTC_RATE) {
+    throw new Error(`Unsupported PCM source rate: ${sourceRate}`);
+  }
+  const input = new Int16Array(pcm.buffer, pcm.byteOffset, Math.floor(pcm.length / 2));
+  const outputLength = Math.max(0, Math.round(input.length * WEBRTC_RATE / sourceRate));
+  const output = Buffer.allocUnsafe(outputLength * 2);
+  const samples = new Int16Array(output.buffer, output.byteOffset, outputLength);
+  const scale = sourceRate / WEBRTC_RATE;
+  for (let i = 0; i < outputLength; i += 1) {
+    const position = i * scale;
+    const left = Math.floor(position);
+    const right = Math.min(left + 1, input.length - 1);
+    const fraction = position - left;
+    samples[i] = Math.round(input[left] + (input[right] - input[left]) * fraction);
+  }
+  return output;
+}
+
+function rmsDbfs(pcm) {
+  if (!pcm?.length) return -Infinity;
+  const samples = new Int16Array(pcm.buffer, pcm.byteOffset, Math.floor(pcm.length / 2));
+  let sum = 0;
+  for (const sample of samples) {
+    const normalized = sample / 32768;
+    sum += normalized * normalized;
+  }
+  if (!sum) return -Infinity;
+  return 20 * Math.log10(Math.sqrt(sum / samples.length));
+}
+
+class TurnDetector {
+  constructor({ thresholdDb = -38, onsetFrames = 3, silenceMs = 700, maxTurnMs = 30000 } = {}) {
+    this.thresholdDb = thresholdDb;
+    this.onsetFrames = onsetFrames;
+    this.silenceFrames = Math.ceil(silenceMs / FRAME_MS);
+    this.maxFrames = Math.ceil(maxTurnMs / FRAME_MS);
+    this.reset();
+  }
+
+  reset() {
+    this.active = false;
+    this.loudFrames = 0;
+    this.quietFrames = 0;
+    this.turnFrames = 0;
+  }
+
+  push(pcm48k) {
+    const loud = rmsDbfs(pcm48k) >= this.thresholdDb;
+    if (!this.active) {
+      this.loudFrames = loud ? this.loudFrames + 1 : 0;
+      if (this.loudFrames >= this.onsetFrames) {
+        this.active = true;
+        this.quietFrames = 0;
+        this.turnFrames = this.loudFrames;
+        return { type: "start" };
+      }
+      return null;
+    }
+    this.turnFrames += 1;
+    this.quietFrames = loud ? 0 : this.quietFrames + 1;
+    if (this.quietFrames >= this.silenceFrames || this.turnFrames >= this.maxFrames) {
+      const reason = this.turnFrames >= this.maxFrames ? "max-duration" : "silence";
+      this.reset();
+      return { type: "commit", reason };
+    }
+    return null;
+  }
+}
+
+module.exports = {
+  FRAME_MS,
+  STT_RATE,
+  WEBRTC_RATE,
+  WEBRTC_SAMPLES,
+  OpusAudioCodec,
+  TurnDetector,
+  downsample48To16,
+  rmsDbfs,
+  upsampleTo48,
+};

package/channels/kazee/call/janus-client.js

@@ -0,0 +1,136 @@
+"use strict";
+
+const crypto = require("crypto");
+const WebSocket = require("ws");
+
+function transactionId() {
+  return crypto.randomBytes(8).toString("hex");
+}
+
+class JanusClient {
+  constructor({ url, WebSocketImpl = WebSocket, requestTimeoutMs = 10000, keepaliveMs = 25000 } = {}) {
+    if (!url) throw new Error("Janus URL is required");
+    this.url = url;
+    this.WebSocketImpl = WebSocketImpl;
+    this.requestTimeoutMs = requestTimeoutMs;
+    this.keepaliveMs = keepaliveMs;
+    this.socket = null;
+    this.sessionId = null;
+    this.pending = new Map();
+    this.handleListeners = new Map();
+    this.keepalive = null;
+  }
+
+  async connect() {
+    if (this.socket) return;
+    const socket = new this.WebSocketImpl(this.url, "janus-protocol");
+    this.socket = socket;
+    socket.on("message", (data) => this._onMessage(data));
+    socket.on("close", () => this._onClose(new Error("Janus socket closed")));
+    socket.on("error", (error) => this._onClose(error));
+    await new Promise((resolve, reject) => {
+      socket.once("open", resolve);
+      socket.once("error", reject);
+    });
+    const created = await this.request({ janus: "create" }, { withSession: false });
+    this.sessionId = created?.data?.id;
+    if (!this.sessionId) throw new Error("Janus create response did not include a session id");
+    this.keepalive = setInterval(() => {
+      this.request({ janus: "keepalive" }).catch((error) => console.error("Janus keepalive:", error.message));
+    }, this.keepaliveMs);
+    this.keepalive.unref?.();
+  }
+
+  async attach(plugin = "janus.plugin.videoroom") {
+    const response = await this.request({ janus: "attach", plugin });
+    const handleId = response?.data?.id;
+    if (!handleId) throw new Error("Janus attach response did not include a handle id");
+    return handleId;
+  }
+
+  onHandle(handleId, listener) {
+    const id = String(handleId);
+    if (!this.handleListeners.has(id)) this.handleListeners.set(id, new Set());
+    this.handleListeners.get(id).add(listener);
+    return () => this.handleListeners.get(id)?.delete(listener);
+  }
+
+  message(handleId, body, jsep) {
+    return this.request({ janus: "message", handle_id: handleId, body, ...(jsep ? { jsep } : {}) });
+  }
+
+  async detach(handleId) {
+    if (!handleId || !this.sessionId) return;
+    try { await this.request({ janus: "detach", handle_id: handleId }); }
+    finally { this.handleListeners.delete(String(handleId)); }
+  }
+
+  request(payload, { withSession = true } = {}) {
+    if (!this.socket || this.socket.readyState !== this.WebSocketImpl.OPEN) {
+      return Promise.reject(new Error("Janus socket is not open"));
+    }
+    const transaction = transactionId();
+    const frame = {
+      ...payload,
+      ...(withSession && this.sessionId ? { session_id: this.sessionId } : {}),
+      transaction,
+    };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(transaction);
+        reject(new Error(`Janus ${payload.janus} timed out`));
+      }, this.requestTimeoutMs);
+      this.pending.set(transaction, { resolve, reject, timer });
+      this.socket.send(JSON.stringify(frame), (error) => {
+        if (!error) return;
+        clearTimeout(timer);
+        this.pending.delete(transaction);
+        reject(error);
+      });
+    });
+  }
+
+  async close() {
+    if (this.keepalive) clearInterval(this.keepalive);
+    this.keepalive = null;
+    if (this.sessionId && this.socket?.readyState === this.WebSocketImpl.OPEN) {
+      try { await this.request({ janus: "destroy" }); } catch (_) {}
+    }
+    this.sessionId = null;
+    const socket = this.socket;
+    this.socket = null;
+    if (socket && socket.readyState < this.WebSocketImpl.CLOSING) socket.close();
+    this._onClose(new Error("Janus client closed"));
+  }
+
+  _onMessage(raw) {
+    let frame;
+    try { frame = JSON.parse(raw.toString()); }
+    catch (_) { return; }
+    const pending = frame.transaction && this.pending.get(frame.transaction);
+    if (pending && frame.janus !== "ack") {
+      clearTimeout(pending.timer);
+      this.pending.delete(frame.transaction);
+      if (frame.janus === "error") pending.reject(new Error(frame.error?.reason || "Janus error"));
+      else pending.resolve(frame);
+    }
+    const sender = frame.sender != null ? String(frame.sender) : null;
+    if (sender) {
+      for (const listener of this.handleListeners.get(sender) || []) {
+        try { listener(frame); } catch (error) { console.error("Janus handle listener:", error.message); }
+      }
+    }
+  }
+
+  _onClose(error) {
+    if (this.keepalive) clearInterval(this.keepalive);
+    this.keepalive = null;
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+}
+
+module.exports = { JanusClient };

package/channels/kazee/call/manager.js

@@ -0,0 +1,109 @@
+"use strict";
+
+const { canonicalForChannel } = require("../../../core/identity");
+const { KazeeCallSession } = require("./session");
+
+const DEFAULT_JANUS_URL = "wss://janus.kazee.africa/ws";
+const DEFAULT_ICE_SERVERS = [
+  { urls: "stun:coturn.kazee.africa:3478" },
+  { urls: "stun:stun.l.google.com:19302" },
+];
+
+class KazeeCallManager {
+  constructor({ adapter, SessionImpl = KazeeCallSession, janusUrl = process.env.KAZEE_JANUS_URL || DEFAULT_JANUS_URL,
+    iceServers = DEFAULT_ICE_SERVERS } = {}) {
+    this.adapter = adapter;
+    this.SessionImpl = SessionImpl;
+    this.janusUrl = janusUrl;
+    this.iceServers = iceServers;
+    this.session = null;
+  }
+
+  wire(socket) {
+    socket.on("call:incoming", (payload) => this.incoming(payload));
+    socket.on("call:ended", (payload) => this.ended(payload));
+    socket.on("call:rejected", (payload) => this.ended(payload));
+  }
+
+  async incoming(payload = {}) {
+    const callerId = String(payload.fromUserId || "");
+    const chatId = String(payload.chatId || "");
+    const roomId = Number(payload.roomId);
+    const callType = String(payload.callType || "");
+    const owner = String(this.adapter.ownerUserId || "");
+    const reject = (reason) => this.adapter._socket?.emit("call:reject", {
+      toUserId: callerId, callType, chatId, roomId, reason,
+    });
+
+    if (!callerId || !chatId || !Number.isSafeInteger(roomId)) return reject("invalid_call");
+    if (callerId !== owner) return reject("not_allowed");
+    if (callType !== "audio") return reject("unsupported_media");
+    if (this.session) return reject("busy");
+
+    const session = new this.SessionImpl({
+      roomId, chatId, callerId, botUserId: this.adapter.botUserId,
+      janusUrl: this.janusUrl, iceServers: this.iceServers,
+      onTranscript: (text) => this._transcript(text, payload),
+      onEnded: () => { if (this.session === session) this.session = null; },
+    });
+    this.session = session;
+    try {
+      await session.start();
+      this.adapter._socket?.emit("call:accept", {
+        toUserId: callerId, callType: "audio", chatId, roomId,
+      });
+    } catch (error) {
+      console.error("Kazee call connect:", error.message);
+      this.session = null;
+      await session.close("connect-failed").catch(() => {});
+      reject("connection_failed");
+    }
+  }
+
+  _transcript(text, incoming) {
+    const session = this.session;
+    if (!session || !text) return;
+    const callAdapter = Object.create(this.adapter);
+    // Provider narration/previews are useful in chat but must never be spoken
+    // into a call. Only the settled, guarded final answer reaches send().
+    callAdapter.suppressStreamPreview = true;
+    callAdapter.send = async (_channelId, response) => {
+      await session.speak(response);
+      return true;
+    };
+    callAdapter.edit = async () => true;
+    callAdapter.typing = async () => {};
+    callAdapter.sendVoice = async (_channelId, voicePath) => {
+      console.warn(`Kazee call ignored file voice response ${voicePath}; streamed TTS is active`);
+      return true;
+    };
+    this.adapter._emit("message", {
+      adapter: callAdapter,
+      channelId: String(incoming.chatId),
+      canonicalUserId: canonicalForChannel("kazee", String(incoming.fromUserId)),
+      userId: String(incoming.fromUserId),
+      type: "text",
+      text,
+      messageId: `call-${incoming.roomId}-${Date.now()}`,
+      from: { id: String(incoming.fromUserId), name: incoming.fromUserName || "" },
+      raw: { ...incoming, source: "kazee-call", ephemeralAudio: true },
+    });
+  }
+
+  async ended(payload = {}) {
+    if (!this.session) return;
+    if (payload.roomId != null && Number(payload.roomId) !== this.session.roomId) return;
+    const session = this.session;
+    this.session = null;
+    await session.close("remote-ended");
+  }
+
+  async stop() {
+    if (!this.session) return;
+    const session = this.session;
+    this.session = null;
+    await session.close("adapter-stopped");
+  }
+}
+
+module.exports = { KazeeCallManager, DEFAULT_ICE_SERVERS, DEFAULT_JANUS_URL };

package/channels/kazee/call/session.js

@@ -0,0 +1,158 @@
+"use strict";
+
+const { MediaStreamTrack, RTCPeerConnection, RtpHeader, RtpPacket } = require("werift");
+const { JanusClient } = require("./janus-client");
+const { OpusAudioCodec, TurnDetector, WEBRTC_SAMPLES, downsample48To16, upsampleTo48 } = require("./audio");
+const { SpeechStream, synthesizePcm } = require("./speech-client");
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+class KazeeCallSession {
+  constructor({ roomId, chatId, callerId, botUserId, janusUrl, iceServers = [], onTranscript, onEnded,
+    JanusClientImpl = JanusClient, PeerConnectionImpl = RTCPeerConnection, SpeechStreamImpl = SpeechStream } = {}) {
+    this.roomId = Number(roomId);
+    this.chatId = String(chatId);
+    this.callerId = String(callerId);
+    this.botUserId = String(botUserId);
+    this.janus = new JanusClientImpl({ url: janusUrl });
+    this.PeerConnectionImpl = PeerConnectionImpl;
+    this.SpeechStreamImpl = SpeechStreamImpl;
+    this.iceServers = iceServers;
+    this.onTranscript = onTranscript || (() => {});
+    this.onEnded = onEnded || (() => {});
+    this.codec = new OpusAudioCodec();
+    this.vad = new TurnDetector();
+    this.stt = new SpeechStreamImpl({ onTranscript: this.onTranscript });
+    this.publisher = null;
+    this.publisherHandle = null;
+    this.subscribers = new Map();
+    this.closed = false;
+    this.sequence = Math.floor(Math.random() * 65535);
+    this.timestamp = Math.floor(Math.random() * 0xffffffff);
+    this.ssrc = Math.floor(Math.random() * 0xffffffff);
+  }
+
+  async start() {
+    await this.janus.connect();
+    this.publisherHandle = await this.janus.attach();
+    this.janus.onHandle(this.publisherHandle, (frame) => this._onPublisherEvent(frame));
+    const joined = await this.janus.message(this.publisherHandle, {
+      request: "join", ptype: "publisher", room: this.roomId, display: `open-claudia:${this.botUserId}`,
+    });
+    await this._consumePublisherFrame(joined);
+    await this.stt.connect();
+  }
+
+  async _onPublisherEvent(frame) {
+    try { await this._consumePublisherFrame(frame); }
+    catch (error) { console.error("Kazee call publisher:", error.message); await this.close("janus-error"); }
+  }
+
+  async _consumePublisherFrame(frame) {
+    const data = frame?.plugindata?.data || {};
+    if (data.error) throw new Error(data.error);
+    for (const publisher of data.publishers || []) {
+      if (!this.subscribers.has(Number(publisher.id)) && !String(publisher.display || "").startsWith("open-claudia:")) {
+        await this._subscribe(Number(publisher.id));
+      }
+    }
+    if (data.videoroom === "joined" && !this.publisher) await this._publish();
+    const gone = Number(data.leaving || data.unpublished || 0);
+    if (gone && this.subscribers.has(gone)) await this._removeSubscriber(gone);
+    if (data.videoroom === "destroyed") await this.close("room-destroyed");
+  }
+
+  async _publish() {
+    if (this.publisher) return;
+    const pc = new this.PeerConnectionImpl({ iceServers: this.iceServers });
+    const track = new MediaStreamTrack({ kind: "audio" });
+    const sender = pc.addTrack(track);
+    this.publisher = { pc, track, sender };
+    const offer = await pc.createOffer();
+    await pc.setLocalDescription(offer);
+    const configured = await this.janus.message(this.publisherHandle, { request: "configure", audio: true, video: false }, pc.localDescription);
+    const answer = configured?.jsep;
+    if (!answer) throw new Error("Janus publisher configure did not return SDP");
+    await pc.setRemoteDescription(answer);
+  }
+
+  async _subscribe(feedId) {
+    const handle = await this.janus.attach();
+    const pc = new this.PeerConnectionImpl({ iceServers: this.iceServers });
+    const sub = { handle, pc };
+    this.subscribers.set(feedId, sub);
+    pc.onTrack.subscribe((track) => {
+      if (track.kind === "audio") track.onReceiveRtp.subscribe((packet) => this._onIncomingRtp(packet));
+    });
+    this.janus.onHandle(handle, (frame) => this._onSubscriberEvent(feedId, frame));
+    const attached = await this.janus.message(handle, { request: "join", ptype: "subscriber", room: this.roomId, feed: feedId });
+    await this._consumeSubscriberFrame(feedId, attached);
+  }
+
+  async _onSubscriberEvent(feedId, frame) {
+    try { await this._consumeSubscriberFrame(feedId, frame); }
+    catch (error) { console.error("Kazee call subscriber:", error.message); await this._removeSubscriber(feedId); }
+  }
+
+  async _consumeSubscriberFrame(feedId, frame) {
+    const sub = this.subscribers.get(feedId);
+    if (!sub) return;
+    const data = frame?.plugindata?.data || {};
+    if (data.error) throw new Error(data.error);
+    if (frame.jsep && !sub.started) {
+      sub.started = true;
+      await sub.pc.setRemoteDescription(frame.jsep);
+      const answer = await sub.pc.createAnswer();
+      await sub.pc.setLocalDescription(answer);
+      await this.janus.message(sub.handle, { request: "start", room: this.roomId }, sub.pc.localDescription);
+    }
+  }
+
+  _onIncomingRtp(packet) {
+    if (this.closed || !packet?.payload?.length) return;
+    let pcm;
+    try { pcm = this.codec.decode(packet.payload); } catch (_) { return; }
+    const event = this.vad.push(pcm);
+    if (this.vad.active || event?.type === "start") this.stt.audio(downsample48To16(pcm)).catch((e) => this.close(`stt:${e.message}`));
+    if (event?.type === "commit") this.stt.commit().catch((e) => this.close(`stt:${e.message}`));
+  }
+
+  async speak(text) {
+    if (this.closed || !String(text || "").trim()) return;
+    const synthesized = await synthesizePcm(String(text));
+    const pcm48 = upsampleTo48(synthesized.pcm, synthesized.sampleRate);
+    for (let offset = 0; offset < pcm48.length && !this.closed; offset += WEBRTC_SAMPLES * 2) {
+      let frame = pcm48.subarray(offset, offset + WEBRTC_SAMPLES * 2);
+      if (frame.length < WEBRTC_SAMPLES * 2) frame = Buffer.concat([frame, Buffer.alloc(WEBRTC_SAMPLES * 2 - frame.length)]);
+      const opus = this.codec.encode(frame);
+      const payloadType = this.publisher?.sender?.codec?.payloadType || 111;
+      this.publisher?.track?.writeRtp(new RtpPacket(new RtpHeader({
+        payloadType, sequenceNumber: this.sequence++ & 0xffff, timestamp: this.timestamp >>> 0, ssrc: this.ssrc,
+      }), opus));
+      this.timestamp = (this.timestamp + WEBRTC_SAMPLES) >>> 0;
+      await wait(20);
+    }
+  }
+
+  async _removeSubscriber(feedId) {
+    const sub = this.subscribers.get(feedId);
+    if (!sub) return;
+    this.subscribers.delete(feedId);
+    try { await sub.pc.close(); } catch (_) {}
+    try { await this.janus.detach(sub.handle); } catch (_) {}
+  }
+
+  async close(reason = "ended") {
+    if (this.closed) return;
+    this.closed = true;
+    this.stt.close();
+    for (const feed of [...this.subscribers.keys()]) await this._removeSubscriber(feed);
+    try { await this.publisher?.pc?.close(); } catch (_) {}
+    try { await this.janus.detach(this.publisherHandle); } catch (_) {}
+    try { await this.janus.close(); } catch (_) {}
+    this.codec.close();
+    this.onEnded(reason);
+  }
+}
+
+module.exports = { KazeeCallSession };

package/channels/kazee/call/speech-client.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const WebSocket = require("ws");
+const { SPEECH_SERVICE_URL } = require("../../../core/config");
+const { speechBearerToken } = require("../../../core/media");
+const ttsVoice = require("../../../core/tts-voice");
+
+class SpeechStream {
+  constructor({ baseUrl = SPEECH_SERVICE_URL, token = speechBearerToken(), WebSocketImpl = WebSocket, onTranscript } = {}) {
+    this.baseUrl = String(baseUrl || "").replace(/\/$/, "");
+    this.token = token;
+    this.WebSocketImpl = WebSocketImpl;
+    this.onTranscript = onTranscript || (() => {});
+    this.socket = null;
+    this.ready = null;
+  }
+
+  async connect() {
+    if (this.ready) return this.ready;
+    if (!this.baseUrl || !this.token) throw new Error("Hosted speech service is not configured");
+    const url = this.baseUrl.replace(/^http/, "ws") + "/v1/audio/transcriptions/stream";
+    this.ready = new Promise((resolve, reject) => {
+      const ws = new this.WebSocketImpl(url, { headers: { Authorization: `Bearer ${this.token}` } });
+      this.socket = ws;
+      ws.once("open", () => {
+        ws.send(JSON.stringify({ sample_rate: 16000, language: "en" }));
+        resolve();
+      });
+      ws.once("error", reject);
+      ws.on("message", (raw) => this._onMessage(raw));
+      ws.on("close", () => { this.socket = null; this.ready = null; });
+    });
+    return this.ready;
+  }
+
+  async audio(pcm16k) {
+    await this.connect();
+    if (this.socket?.readyState === this.WebSocketImpl.OPEN) this.socket.send(pcm16k);
+  }
+
+  async commit() {
+    await this.connect();
+    this.socket.send(JSON.stringify({ type: "commit" }));
+  }
+
+  _onMessage(raw) {
+    let message;
+    try { message = JSON.parse(raw.toString()); } catch (_) { return; }
+    const text = String(message.text || message.transcript || "").trim();
+    if (text && (message.final === true || message.type === "final" || message.type === "transcription")) {
+      Promise.resolve(this.onTranscript(text)).catch((error) => console.error("Kazee call transcript:", error.message));
+    }
+  }
+
+  close() {
+    const ws = this.socket;
+    this.socket = null;
+    this.ready = null;
+    if (ws?.readyState === this.WebSocketImpl.OPEN) ws.send(JSON.stringify({ type: "close" }));
+    try { ws?.close(); } catch (_) {}
+  }
+}
+
+async function synthesizePcm(text, { baseUrl = SPEECH_SERVICE_URL, token = speechBearerToken(), fetchImpl = fetch } = {}) {
+  if (!baseUrl || !token) throw new Error("Hosted speech service is not configured");
+  const response = await fetchImpl(`${String(baseUrl).replace(/\/$/, "")}/v1/audio/speech`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ input: text, voice: ttsVoice.getVoice(), response_format: "pcm" }),
+    signal: AbortSignal.timeout(60000),
+  });
+  if (!response.ok) throw new Error(`Hosted TTS failed: HTTP ${response.status}`);
+  const contentType = response.headers?.get?.("content-type") || "";
+  const rate = Number(contentType.match(/(?:^|;)\s*rate=(\d+)/i)?.[1] || 24000);
+  if (!Number.isFinite(rate) || rate < 8000 || rate > 48000) throw new Error(`Hosted TTS returned invalid PCM rate: ${rate}`);
+  return { pcm: Buffer.from(await response.arrayBuffer()), sampleRate: rate };
+}
+
+module.exports = { SpeechStream, synthesizePcm };

package/core/runner.js

@@ -1765,7 +1765,9 @@ const STREAM_PREVIEW_FOOTER = "\n\n⏳ working — /stop to cancel";
 // the narration as it happens instead of silence. finalizeStreamPreview
 // settles the message when the run ends.
 function createStreamPreview({ state, store }) {
-  let enabled = !!store && (store?.adapter?.type || "") !== "voice";
+  let enabled = !!store
+    && (store?.adapter?.type || "") !== "voice"
+    && store?.adapter?.suppressStreamPreview !== true;
   if (enabled) {
     // Interim text is NOT vetted by guardOutboundReply (only the final answer
     // is), so it must never reach a guarded external speaker. Fail closed if

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.1.12",
+  "version": "3.1.13",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {
     "open-claudia": "./bin/cli.js"
   },
   "scripts": {
+    "test:kazee-call": "node test-kazee-call-audio.js && node test-kazee-call-janus.js && node test-kazee-call-webrtc.js && node test-kazee-call-speech.js && node test-kazee-call-manager.js",
     "setup": "node setup.js",
     "start": "node bot.js",
     "pretest": "node test-provider-fixture.js && node test-provider-core-prompt.js && node test-turn-observer.js && node test-provider-prompt-parity.js && node test-provider-env-isolation.js && node test-provider-resume-parity.js && node test-provider-bootstrap.js && node test-provider-registry.js && node test-provider-stream-decoder.js && node test-provider-events.js && node test-provider-claude.js && node test-provider-codex.js && node test-provider-runner.js && node test-provider-refusal-recovery.js && node test-provider-run-lifecycle.js && node test-provider-gateway.js && node test-provider-side-chat.js && node test-single-runtime.js && node test-provider-migration-backup.js && node test-provider-state-migration.js && node test-provider-session-history.js && node test-provider-session-commands.js && node test-provider-compaction.js && node test-provider-scheduler.js && node test-credential-capture.js && node test-cursor-removal.js && node test-utility-provider-policy.js && node test-provider-subagent.js && node test-provider-recall.js && node test-provider-pack-review.js && node test-memory-mutation-queue.js && node test-provider-dream.js && node test-provider-enforcer.js && node test-provider-tool-hooks.js && node test-provider-boot-matrix.js && node test-provider-capabilities.js && node test-provider-language.js && node test-provider-coupling-audit.js && node test-provider-parity-e2e.js && node test-kazee-channel-health.js && node test-kazee-media-caption.js && node test-prompt-budget.js && node test-agency-ledger.js && node test-agency-deliberate.js && node test-guardrail.js && node test-spaces-comment-content.js && node test-boot-health.js && node test-lexical-floor.js && node test-safe-mode.js && node test-logout.js",
@@ -134,10 +135,15 @@
   "engines": {
     "node": ">=24.0.0"
   },
+  "overrides": {
+    "ws": "^8.21.1"
+  },
   "dependencies": {
     "node-cron": "^4.2.1",
     "node-telegram-bot-api": "^0.67.0",
+    "opusscript": "^0.1.1",
     "socket.io-client": "^4.7.5",
-    "ws": "^8.18.0"
+    "werift": "^0.23.0",
+    "ws": "^8.21.1"
   }
 }

package/test-provider-language.js

@@ -204,7 +204,10 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // Custom hf:// escape hatch) plus voice cloning — send a clip and it's transcoded
 // (ogg->24kHz mono wav) and registered via the speech gateway /v1/voices as the
 // active stored:<digest> voice. Plus this version-pin bump.
-assert.strictEqual(pkg.version, "3.1.12", "release version must remain unchanged without explicit approval");
+// 3.1.13 approved by Sumeet 2026-07-22 ("work through till all your plan is
+// completed"): owner-only incoming Kazee audio calls bridge Janus VideoRoom
+// RTP to hosted streaming STT, the normal agent turn, and streamed Pocket TTS.
+assert.strictEqual(pkg.version, "3.1.13", "release version must remain unchanged without explicit approval");
 for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
   assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
 }