@inetafrica/open-claudia 3.1.12 → 3.1.14

package/test-kazee-call-session.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+"use strict";
+
+const assert = require("assert");
+const { KazeeCallSession } = require("./channels/kazee/call/session");
+const { KazeeCallManager } = require("./channels/kazee/call/manager");
+const { OpusAudioCodec, WEBRTC_SAMPLES } = require("./channels/kazee/call/audio");
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+class FakeJanus {
+  constructor() { this.handles = 0; }
+  async connect() {}
+  async attach() { this.handles += 1; return this.handles; }
+  onHandle() {}
+  async message() { return {}; }
+  async detach() {}
+  async close() {}
+}
+
+class FakePC {
+  constructor() { this.onTrack = { subscribe: () => {} }; }
+  addTrack() { return { codec: { payloadType: 111 } }; }
+  async createOffer() { return {}; }
+  async setLocalDescription() {}
+  async createAnswer() { return {}; }
+  async setRemoteDescription() {}
+  async close() {}
+}
+
+class FakeSpeechStream {
+  constructor({ onTranscript } = {}) {
+    this.onTranscript = onTranscript;
+    this.audioFrames = [];
+    this.commits = 0;
+    this.closedStream = false;
+  }
+  async connect() {}
+  async audio(buffer) { this.audioFrames.push(buffer); }
+  async commit() { this.commits += 1; }
+  close() { this.closedStream = true; }
+}
+
+function makeSession({ synthesize, maxCallMs, idleMs } = {}) {
+  const ended = [];
+  const transcripts = [];
+  const session = new KazeeCallSession({
+    roomId: 7, chatId: "chat", callerId: "owner", botUserId: "bot", janusUrl: "ws://test",
+    maxCallMs, idleMs,
+    synthesize: synthesize || (async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 2), sampleRate: 48000 })),
+    onTranscript: (text, meta) => transcripts.push({ text, meta }),
+    onEnded: (reason) => ended.push(reason),
+    JanusClientImpl: FakeJanus, PeerConnectionImpl: FakePC, SpeechStreamImpl: FakeSpeechStream,
+  });
+  return { session, ended, transcripts };
+}
+
+function toneOpus(codec, amplitude) {
+  const pcm = Buffer.alloc(WEBRTC_SAMPLES * 2);
+  const view = new Int16Array(pcm.buffer, pcm.byteOffset, WEBRTC_SAMPLES);
+  for (let i = 0; i < view.length; i += 1) view[i] = Math.round(Math.sin(2 * Math.PI * 440 * i / 48000) * amplitude);
+  return codec.encode(pcm);
+}
+
+async function testSpeakSerialization() {
+  const writes = [];
+  const synthCalls = [];
+  let current = null;
+  const { session } = makeSession({
+    synthesize: async (text) => { synthCalls.push(text); current = text; return { pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 3), sampleRate: 48000 }; },
+  });
+  session.publisher = { track: { writeRtp: () => writes.push(current) }, sender: { codec: { payloadType: 111 } } };
+  const [first, second] = await Promise.all([session.speak("one"), session.speak("two")]);
+  assert.strictEqual(first, true);
+  assert.strictEqual(second, true);
+  assert.deepStrictEqual(synthCalls, ["one", "two"], "synthesis is sequential");
+  assert.deepStrictEqual(writes, ["one", "one", "one", "two", "two", "two"], "utterances never interleave on the RTP stream");
+  await session.close();
+}
+
+async function testSpeakCancellation() {
+  let frames = 0;
+  const synthCalls = [];
+  const { session } = makeSession({
+    synthesize: async (text) => { synthCalls.push(text); return { pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 50), sampleRate: 48000 }; },
+  });
+  session.publisher = { track: { writeRtp: () => { frames += 1; } }, sender: { codec: { payloadType: 111 } } };
+  const playing = session.speak("long");
+  const queued = session.speak("queued");
+  await wait(80);
+  session.cancelSpeech();
+  assert.strictEqual(await playing, false, "current utterance reports cancelled");
+  assert.strictEqual(await queued, false, "queued utterance cancelled");
+  assert(frames < 20, `playback stopped early (${frames} frames)`);
+  assert.deepStrictEqual(synthCalls, ["long"], "queued text never synthesized after cancel");
+  assert.strictEqual(session.speaking, false);
+  await session.close();
+}
+
+async function testEchoGateAndBargeIn() {
+  const { session } = makeSession({
+    synthesize: async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 100), sampleRate: 48000 }),
+  });
+  await session._subscribe(101, "sumeet@kazee");
+  const sub = session.subscribers.get(101);
+  const gen = new OpusAudioCodec();
+  session.publisher = { track: { writeRtp: () => {} }, sender: { codec: { payloadType: 111 } } };
+  const playing = session.speak("long answer");
+  await wait(30);
+  assert.strictEqual(session.speaking, true);
+  for (let i = 0; i < 6; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 1500) }); // ~-30dB: echo territory
+  assert.strictEqual(session.speaking, true, "echo-level audio does not interrupt TTS");
+  assert.strictEqual(sub.stt.audioFrames.length, 0, "echo-level audio is not streamed to STT");
+  for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) }); // ~-12dB: real speech
+  assert.strictEqual(await playing, false, "barge-in cancels TTS");
+  assert(sub.stt.audioFrames.length >= 3, "barge-in speech reaches STT");
+  gen.close();
+  await session.close();
+}
+
+async function testPrebufferAndCommit() {
+  const { session } = makeSession({});
+  await session._subscribe(101, "caller");
+  const sub = session.subscribers.get(101);
+  const gen = new OpusAudioCodec();
+  for (let i = 0; i < 5; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 30) }); // near-silence
+  assert.strictEqual(sub.stt.audioFrames.length, 0, "silence stays out of STT");
+  for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) });
+  assert.strictEqual(sub.stt.audioFrames.length, 8, "onset flushes the prebuffer (5 quiet + 2 onset + current)");
+  for (let i = 0; i < 36; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 30) });
+  assert.strictEqual(sub.stt.commits, 1, "turn commits after sustained silence");
+  gen.close();
+  await session.close();
+}
+
+async function testTranscriptAttribution() {
+  const { session, transcripts } = makeSession({});
+  await session._subscribe(101, "alice@kazee");
+  await session._subscribe(102, "bob@kazee");
+  session.subscribers.get(101).stt.onTranscript("hello there");
+  assert.deepStrictEqual(transcripts[0], {
+    text: "hello there",
+    meta: { feedId: 101, display: "alice@kazee", participants: 2 },
+  });
+  await session.close();
+
+  class FakeSession {
+    constructor(options) { this.options = options; this.roomId = options.roomId; }
+    async start() {}
+    async speak() {}
+    async close(reason) { this.options.onEnded(reason); }
+  }
+  const inbound = [];
+  const adapter = { ownerUserId: "owner-1", botUserId: "bot-1", _socket: { on() {}, emit() {} }, _emit: (name, payload) => inbound.push(payload) };
+  const manager = new KazeeCallManager({ adapter, SessionImpl: FakeSession });
+  await manager.incoming({ fromUserId: "owner-1", chatId: "c", roomId: 5, callType: "audio" });
+  manager.session.options.onTranscript("hi", { feedId: 1, display: "alice@kazee", participants: 2 });
+  assert.strictEqual(inbound[0].text, "alice@kazee: hi", "group transcripts are speaker-prefixed");
+  assert.strictEqual(inbound[0].raw.speaker, "alice@kazee");
+  manager.session.options.onTranscript("solo", { feedId: 1, display: "alice@kazee", participants: 1 });
+  assert.strictEqual(inbound[1].text, "solo", "1:1 transcripts stay unprefixed");
+  await manager.stop();
+}
+
+async function testIdleTimeout() {
+  const goodbyes = [];
+  const { session, ended } = makeSession({
+    idleMs: 50, maxCallMs: 60_000,
+    synthesize: async (text) => { goodbyes.push(text); return { pcm: Buffer.alloc(WEBRTC_SAMPLES * 2), sampleRate: 48000 }; },
+  });
+  session._startedAt = Date.now();
+  session._lastHeard = Date.now() - 1000;
+  session._lastSpokeAt = Date.now() - 1000;
+  await session._enforceLimits();
+  assert.strictEqual(ended[0], "idle-timeout");
+  assert.strictEqual(goodbyes.length, 1, "idle hangup says goodbye first");
+  assert(goodbyes[0].toLowerCase().includes("hang up"));
+}
+
+async function testIdleBargeInKeepsCall() {
+  let sess = null;
+  const { session, ended } = makeSession({
+    idleMs: 50, maxCallMs: 60_000,
+    synthesize: async () => { sess._lastHeard = Date.now(); return { pcm: Buffer.alloc(WEBRTC_SAMPLES * 2), sampleRate: 48000 }; },
+  });
+  sess = session;
+  session._startedAt = Date.now();
+  session._lastHeard = Date.now() - 1000;
+  session._lastSpokeAt = Date.now() - 1000;
+  await session._enforceLimits();
+  assert.strictEqual(ended.length, 0, "call stays up when the caller speaks during the goodbye");
+  assert.strictEqual(session._ending, false);
+  await session.close();
+}
+
+async function testMaxDuration() {
+  const { session, ended } = makeSession({ idleMs: 60_000, maxCallMs: 50 });
+  session._startedAt = Date.now() - 1000;
+  session._lastHeard = Date.now();
+  session._lastSpokeAt = Date.now();
+  await session._enforceLimits();
+  assert.strictEqual(ended[0], "max-duration", "cap closes the call even mid-conversation");
+}
+
+async function testCloseResolvesSpeech() {
+  const { session } = makeSession({
+    synthesize: async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 100), sampleRate: 48000 }),
+  });
+  await session._subscribe(101, "x");
+  const sub = session.subscribers.get(101);
+  const playing = session.speak("very long");
+  await wait(40);
+  await session.close("ended");
+  assert.strictEqual(await playing, false, "in-flight speak resolves on close");
+  assert.strictEqual(sub.stt.closedStream, true, "per-feed STT closed with the call");
+  assert.strictEqual(session.subscribers.size, 0);
+  assert.strictEqual(await session.speak("after"), false, "speak after close is a no-op");
+}
+
+(async () => {
+  await testSpeakSerialization();
+  await testSpeakCancellation();
+  await testEchoGateAndBargeIn();
+  await testPrebufferAndCommit();
+  await testTranscriptAttribution();
+  await testIdleTimeout();
+  await testIdleBargeInKeepsCall();
+  await testMaxDuration();
+  await testCloseResolvesSpeech();
+  console.log("kazee call session: ok");
+})().catch((error) => { console.error(error); process.exitCode = 1; });

package/test-kazee-call-speech.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+"use strict";
+const assert = require("assert");
+const { EventEmitter } = require("events");
+const { SpeechStream, synthesizePcm } = require("./channels/kazee/call/speech-client");
+class FakeWebSocket extends EventEmitter {
+  static OPEN = 1;
+  constructor(url, options) { super(); this.url = url; this.options = options; this.readyState = 1; this.sent = []; queueMicrotask(() => this.emit("open")); }
+  send(value) { this.sent.push(value); }
+  close() { this.readyState = 3; this.emit("close"); }
+}
+(async () => {
+  let transcript;
+  const stream = new SpeechStream({ baseUrl: "https://speech.example", token: "secret", WebSocketImpl: FakeWebSocket, onTranscript: (t) => { transcript = t; } });
+  await stream.connect();
+  assert.strictEqual(stream.socket.url, "wss://speech.example/v1/audio/transcriptions/stream");
+  assert.deepStrictEqual(JSON.parse(stream.socket.sent[0]), { sample_rate: 16000, language: "en" });
+  await stream.audio(Buffer.from([1, 2]));
+  await stream.commit();
+  assert(Buffer.isBuffer(stream.socket.sent[1]));
+  stream.socket.emit("message", Buffer.from(JSON.stringify({ type: "final", text: "hello" })));
+  assert.strictEqual(transcript, "hello");
+  let request;
+  const pcm = await synthesizePcm("Hello", { baseUrl: "https://speech.example", token: "secret", fetchImpl: async (url, options) => {
+    request = { url, options }; return {
+      ok: true,
+      headers: { get: () => "audio/pcm;rate=24000;encoding=signed-integer;bits=16" },
+      arrayBuffer: async () => Uint8Array.from([1, 2, 3]).buffer,
+    };
+  } });
+  assert.strictEqual(JSON.parse(request.options.body).response_format, "pcm");
+  assert.strictEqual(pcm.sampleRate, 24000);
+  assert.deepStrictEqual([...pcm.pcm], [1, 2, 3]);
+  stream.close();
+  console.log("kazee call speech: ok");
+})().catch((error) => { console.error(error); process.exitCode = 1; });

package/test-kazee-call-webrtc.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+"use strict";
+
+const assert = require("assert");
+const { MediaStreamTrack, RTCPeerConnection, RtpHeader, RtpPacket } = require("werift");
+const { OpusAudioCodec, WEBRTC_SAMPLES } = require("./channels/kazee/call/audio");
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function main() {
+  const publisher = new RTCPeerConnection();
+  const subscriber = new RTCPeerConnection();
+  const outgoing = new MediaStreamTrack({ kind: "audio" });
+  const sender = publisher.addTrack(outgoing);
+  let resolvePacket;
+  const received = new Promise((resolve) => { resolvePacket = resolve; });
+  subscriber.onTrack.subscribe((track) => track.onReceiveRtp.subscribe(resolvePacket));
+
+  const offer = await publisher.createOffer();
+  await publisher.setLocalDescription(offer);
+  await subscriber.setRemoteDescription(publisher.localDescription);
+  const answer = await subscriber.createAnswer();
+  await subscriber.setLocalDescription(answer);
+  await publisher.setRemoteDescription(subscriber.localDescription);
+
+  for (let attempt = 0; attempt < 100 && publisher.connectionState !== "connected"; attempt += 1) await wait(20);
+  assert.strictEqual(publisher.connectionState, "connected", "local WebRTC peers connect");
+
+  const pcm = Buffer.alloc(WEBRTC_SAMPLES * 2);
+  const samples = new Int16Array(pcm.buffer, pcm.byteOffset, WEBRTC_SAMPLES);
+  for (let i = 0; i < samples.length; i += 1) samples[i] = Math.round(Math.sin(2 * Math.PI * 440 * i / 48000) * 12000);
+  const codec = new OpusAudioCodec();
+  const opus = codec.encode(pcm);
+  outgoing.writeRtp(new RtpPacket(new RtpHeader({
+    payloadType: sender.codec?.payloadType || 111,
+    sequenceNumber: 1,
+    timestamp: WEBRTC_SAMPLES,
+    ssrc: 0x0c1a0d10,
+  }), opus));
+
+  const packet = await Promise.race([received, wait(3000).then(() => null)]);
+  assert(packet, "encrypted WebRTC path delivers an RTP packet");
+  assert.deepStrictEqual(packet.payload, opus, "Opus payload survives ICE/DTLS/SRTP transport");
+  assert.strictEqual(codec.decode(packet.payload).length, pcm.length, "received Opus decodes to a 20ms PCM frame");
+
+  codec.close();
+  await publisher.close();
+  await subscriber.close();
+  console.log("kazee call WebRTC loopback: ok");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/test-provider-language.js

@@ -204,7 +204,15 @@ 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.
+// 3.1.14 approved by Sumeet 2026-07-22 (calls deep-dive: "you're welcome to go
+// ahead and work through all the way until everything's deployed"): call bridge
+// production hardening — serialized TTS with barge-in cancellation, echo gate,
+// per-feed STT with group speaker attribution, duration/idle limits with a
+// spoken goodbye, and the call tests wired into the main npm test chain.
+assert.strictEqual(pkg.version, "3.1.14", "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}`);
 }