@inetafrica/open-claudia 3.1.14 → 3.1.17

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## v3.1.17 — Call bridge joins through the caller's room-setup race (fixes "Call declined")
+
+- Answering a Kazee web call could fail deterministically fast: the caller creates the Janus videoroom during its own dial-time setup, and the bot answers quicker than any human — its `join` hit Janus before the room existed, got 426 "No such room", and the whole call was rejected as `connection_failed` (surfacing as "Call declined" in the web UI).
+- `session.start()` now polls the publisher join through transient 426 (10 attempts × 500ms), mirroring the web receiver's own retry loop in `CallContext.startVideoRoom`. Persistent 426 still fails the call.
+- Janus error frames now carry `error.code` alongside the message for future discrimination.
+- New assertions: join retries through transient no-such-room and still gives up when the room never appears.
+
+## v3.1.16 — CI-deflake: no live network in unit tests, CI-safe enforcer deadlines
+
+- Identical bot behaviour to v3.1.15 (which never shipped: its pipeline died twice on loaded-runner test flakes — the tag is retired unretagged per release hygiene).
+- `test-telegram-conflict-heal-guard.js` stubbed `_probeTelegramReachable`/`_anyTurnActive`: the wedge-exit assertion used to probe the real api.telegram.org, so a slow/blocked CI egress sent `_heal` down the outage-pause path instead of the exit under test. It also now isolates `OPEN_CLAUDIA_CONFIG_DIR` — the exercised exit path was writing a bogus "polling wedged" `last-exit.json` into the real `~/.open-claudia` on every local test run.
+- `test-provider-enforcer.js` deadlines made CI-safe: the judged-probe service backstop 2000→8000ms (children answer in ms; 2000 was missed by child boot under runner load), the deliberate-timeout probe 2500→5000ms boot headroom.
+
+## v3.1.15 — Voice-note replies speak a conversational summary, not the chat text
+
+- Replying to a voice note used to TTS the full formatted chat answer verbatim — bullets, emoji, pipeline IDs and all ("this isn't human hearable"). On voice-reply turns the provider is now asked to end its reply with a dedicated spoken script in `<voice-script>` markers: the chat message keeps the full text answer (script stripped), and only the script — two to four conversational sentences written for the ear — is synthesized into the voice note.
+- If the provider omits the script, a sanitizing fallback (`speechFallback`) strips code blocks, HTML, URLs, emoji, and list markers, caps the speech at the opening sentences, and closes with "The rest is in the text message." — a verbatim readout can no longer reach TTS on text channels.
+- The Kazee call bridge keeps its existing in-call guidance and streams `voiceScript || finalText`, so stray markers are never spoken there either.
+- New extraction/fallback/wiring assertions in `test-media-speech.js`.
+
 ## v3.1.14 — Call bridge production hardening: serialized speech, barge-in, group attribution, limits
 
 - **TTS is serialized through a queue with cancellation.** Concurrent `speak()` calls used to interleave two 20ms-frame RTP loops over the same sequence/timestamp counters — garbled audio whenever the provider emitted more than one message. Utterances now play strictly one at a time; `cancelSpeech()` (generation-based) stops the current utterance mid-frame and resolves everything queued, and `close()` cancels so no pending `speak()` can hang the adapter.

package/channels/kazee/call/session.js

@@ -15,6 +15,8 @@ const PREBUFFER_FRAMES = 12; // 240ms of pre-onset audio so first syllables reac
 const LIMIT_CHECK_MS = 10_000;
 const DEFAULT_MAX_CALL_MS = 30 * 60_000;
 const DEFAULT_IDLE_MS = 2 * 60_000;
+const DEFAULT_JOIN_RETRIES = 10;
+const DEFAULT_JOIN_RETRY_DELAY_MS = 500;
 const MAX_DURATION_GOODBYE = "We've hit the call time limit, so I'll hang up now. Message me any time.";
 const IDLE_GOODBYE = "I haven't heard anything for a while, so I'll hang up now. Message me any time.";
 
@@ -35,6 +37,8 @@ class KazeeCallSession {
     this.synthesize = synthesize;
     this.maxCallMs = Number(maxCallMs ?? process.env.KAZEE_CALL_MAX_MS) || DEFAULT_MAX_CALL_MS;
     this.idleMs = Number(idleMs ?? process.env.KAZEE_CALL_IDLE_MS) || DEFAULT_IDLE_MS;
+    this.joinRetries = DEFAULT_JOIN_RETRIES;
+    this.joinRetryDelayMs = DEFAULT_JOIN_RETRY_DELAY_MS;
     this.codec = new OpusAudioCodec();
     this.publisher = null;
     this.publisherHandle = null;
@@ -58,9 +62,20 @@ class KazeeCallSession {
     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}`,
-    });
+    // The caller creates the Janus room during its own call setup, which can
+    // land a beat after the invite reaches us — and a bot answers faster than
+    // any human. Poll join through transient 426 "No such room" like the web
+    // receiver's retry loop in CallContext.startVideoRoom.
+    let joined;
+    for (let attempt = 0; ; attempt += 1) {
+      joined = await this.janus.message(this.publisherHandle, {
+        request: "join", ptype: "publisher", room: this.roomId, display: `open-claudia:${this.botUserId}`,
+      });
+      const data = joined?.plugindata?.data || {};
+      const noRoom = Number(data.error_code) === 426 || /no such room/i.test(String(data.error || ""));
+      if (!noRoom || attempt >= this.joinRetries || this.closed) break;
+      await wait(this.joinRetryDelayMs);
+    }
     await this._consumePublisherFrame(joined);
     this._startedAt = Date.now();
     this._lastHeard = this._startedAt;
@@ -76,7 +91,11 @@ class KazeeCallSession {
 
   async _consumePublisherFrame(frame) {
     const data = frame?.plugindata?.data || {};
-    if (data.error) throw new Error(data.error);
+    if (data.error) {
+      const error = new Error(data.error);
+      if (data.error_code != null) error.code = Number(data.error_code);
+      throw error;
+    }
     for (const publisher of data.publishers || []) {
       const feedId = Number(publisher.id);
       if (!this.subscribers.has(feedId) && !String(publisher.display || "").startsWith("open-claudia:")) {
@@ -135,7 +154,11 @@ class KazeeCallSession {
     const sub = this.subscribers.get(feedId);
     if (!sub) return;
     const data = frame?.plugindata?.data || {};
-    if (data.error) throw new Error(data.error);
+    if (data.error) {
+      const error = new Error(data.error);
+      if (data.error_code != null) error.code = Number(data.error_code);
+      throw error;
+    }
     if (frame.jsep && !sub.started) {
       sub.started = true;
       await sub.pc.setRemoteDescription(frame.jsep);

package/core/runner.js

@@ -1647,6 +1647,18 @@ async function deliverForegroundResult(result, runContext, state = currentState(
     }
   }
 
+  // The <voice-script> block (if the provider wrote one) is a spoken summary
+  // for the voice note — strip it from the chat text; the guard above already
+  // vetted the full output including the script.
+  const { VOICE_REPLY_MODE } = require("./config");
+  const { shouldReplyWithVoice, extractVoiceScript, speechFallback } = require("./voice-policy");
+  let voiceScript = "";
+  if (result.ok) {
+    const parts = extractVoiceScript(finalText);
+    voiceScript = parts.script;
+    finalText = parts.text || parts.script || finalText;
+  }
+
   const chunks = splitMessage(finalText);
   for (let index = 0; index < chunks.length; index += 1) {
     let sent = await send(chunks[index], telegramHtmlOpts(index === 0 ? { replyTo: runContext.replyToMsgId } : {}));
@@ -1654,25 +1666,26 @@ async function deliverForegroundResult(result, runContext, state = currentState(
     if (!sent.ok) throw new Error(`failed to deliver response chunk ${index + 1}`);
   }
 
-  const { VOICE_REPLY_MODE } = require("./config");
-  const { shouldReplyWithVoice } = require("./voice-policy");
   const shouldSpeak = shouldReplyWithVoice(VOICE_REPLY_MODE, runContext.lastInputWasVoice);
   if (result.ok && shouldSpeak) {
     const { currentTransport } = require("./context");
     if (currentTransport() === "voice") {
-      const sentences = splitSentences(finalText);
+      const sentences = splitSentences(voiceScript || finalText);
       let spoke = false;
       for (const sentence of sentences) {
         const clip = await synthSentenceMp3(sentence);
         if (clip) { spoke = true; await sendVoice(clip); }
       }
       if (!spoke) {
-        const voicePath = await textToVoice(finalText);
+        const voicePath = await textToVoice(voiceScript || finalText);
         if (voicePath) await sendVoice(voicePath);
       }
       await sendVoiceEnd();
     } else {
-      const voicePath = await textToVoice(finalText);
+      // Never TTS the formatted chat text verbatim: use the provider's spoken
+      // script, else a sanitized short fallback.
+      const spoken = voiceScript || speechFallback(finalText);
+      const voicePath = spoken ? await textToVoice(spoken) : null;
       if (voicePath) await sendVoice(voicePath);
     }
   }

package/core/system-prompt.js

@@ -995,10 +995,29 @@ const VOICE_REPLY_GUIDANCE = [
   "- If the answer genuinely needs code or exact detail, say so briefly and offer to send it as text rather than reading it aloud.",
 ].join("\n");
 
+// Text-channel voice turns (a Telegram/Kazee voice note): the chat reply stays
+// a normal full text answer, but a voice note is ALSO sent back. Asking for a
+// dedicated spoken script — stripped from the text by the runner — is what
+// keeps that voice note conversational instead of a verbatim TTS of the
+// formatted chat text.
+const VOICE_NOTE_GUIDANCE = [
+  "",
+  "",
+  "## Voice note reply",
+  "The user sent this message as a voice note, and a spoken voice note will be sent back alongside your text reply. Do both:",
+  "- Write your normal text reply as usual — full detail and formatting are fine; it is delivered as text.",
+  "- End the reply with a spoken script between <voice-script> and </voice-script> markers. That block is stripped from the text message and only synthesized to audio.",
+  "Script rules: two to four short sentences a person would naturally SAY — summarise the essence conversationally, do not re-read the text reply. No formatting, no emoji, no lists. Never speak code, IDs, file paths, URLs, or command syntax — describe them in plain words or say the details are in the text message.",
+].join("\n");
+
 function voiceReplyGuidance(opts = {}) {
   try {
     const { currentTransport } = require("./context");
-    if (currentTransport() === "voice" && promptState(opts).lastInputWasVoice) return VOICE_REPLY_GUIDANCE;
+    const state = promptState(opts);
+    if (currentTransport() === "voice") return state.lastInputWasVoice ? VOICE_REPLY_GUIDANCE : "";
+    const { VOICE_REPLY_MODE } = require("./config");
+    const { shouldReplyWithVoice } = require("./voice-policy");
+    if (shouldReplyWithVoice(VOICE_REPLY_MODE, state.lastInputWasVoice)) return VOICE_NOTE_GUIDANCE;
   } catch (e) {}
   return "";
 }

package/core/voice-policy.js

@@ -4,4 +4,49 @@ function shouldReplyWithVoice(mode, lastInputWasVoice) {
   return mode === "always" || (mode === "on-voice-input" && !!lastInputWasVoice);
 }
 
-module.exports = { shouldReplyWithVoice };
+// On voice-reply turns the provider is asked (system-prompt voice-note
+// guidance) to end its reply with a spoken script between these markers. The
+// block is stripped from the chat text and ONLY synthesized — chat keeps the
+// full formatted answer while the voice note carries an ear-friendly summary
+// instead of a verbatim TTS readout of bullets, emoji, and IDs.
+const VOICE_SCRIPT_RE = /<voice-script>([\s\S]*?)(?:<\/voice-script>|$)/gi;
+
+function extractVoiceScript(text) {
+  const raw = String(text || "");
+  const scripts = [];
+  const stripped = raw.replace(VOICE_SCRIPT_RE, (_match, body) => {
+    const clean = String(body || "").trim();
+    if (clean) scripts.push(clean);
+    return "";
+  });
+  return { text: stripped.trim(), script: scripts.join(" ").trim() };
+}
+
+// Last-resort shaping when the provider supplied no <voice-script>: strip
+// everything that reads badly aloud and cap to the opening sentences, so a
+// missed script degrades to a short spoken intro rather than a verbatim dump
+// of formatted text into TTS.
+const FALLBACK_MAX_CHARS = 400;
+
+function speechFallback(text) {
+  const plain = String(text || "")
+    .replace(/```[\s\S]*?```/g, " ")
+    .replace(/<[^>\n]{0,120}>/g, " ")
+    .replace(/https?:\/\/\S+/gi, " ")
+    .replace(/[\u{1F000}-\u{1FAFF}\u{2600}-\u{27BF}\u{2B00}-\u{2BFF}\u{FE0F}\u{200D}]/gu, "")
+    .replace(/^\s*[-*•▸►]+\s+/gm, "")
+    .replace(/[*_`#|]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (plain.length <= FALLBACK_MAX_CHARS) return plain;
+  const sentences = plain.match(/[^.!?]+[.!?]+(?:\s+|$)/g) || [];
+  let out = "";
+  for (const sentence of sentences) {
+    if (out && out.length + sentence.length > FALLBACK_MAX_CHARS) break;
+    out += sentence;
+  }
+  out = out.trim() || plain.slice(0, FALLBACK_MAX_CHARS).trim();
+  return `${out} The rest is in the text message.`;
+}
+
+module.exports = { shouldReplyWithVoice, extractVoiceScript, speechFallback };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.1.14",
+  "version": "3.1.17",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {

package/test-kazee-call-session.js

@@ -202,6 +202,32 @@ async function testMaxDuration() {
   assert.strictEqual(ended[0], "max-duration", "cap closes the call even mid-conversation");
 }
 
+async function testJoinRetriesNoSuchRoom() {
+  const { session } = makeSession({});
+  session.joinRetryDelayMs = 1;
+  let joins = 0;
+  session.janus.message = async (_handle, body) => {
+    if (body?.request !== "join") return {};
+    joins += 1;
+    if (joins < 3) return { plugindata: { data: { videoroom: "event", error_code: 426, error: "No such room (7)" } } };
+    return {};
+  };
+  await session.start();
+  assert.strictEqual(joins, 3, "join retried through transient no-such-room");
+  await session.close();
+}
+
+async function testJoinGivesUpAfterRetries() {
+  const { session } = makeSession({});
+  session.joinRetryDelayMs = 1;
+  session.joinRetries = 2;
+  session.janus.message = async (_handle, body) => body?.request === "join"
+    ? { plugindata: { data: { videoroom: "event", error_code: 426, error: "No such room (7)" } } }
+    : {};
+  await assert.rejects(() => session.start(), /No such room/, "persistent 426 still fails the call");
+  await session.close();
+}
+
 async function testCloseResolvesSpeech() {
   const { session } = makeSession({
     synthesize: async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 100), sampleRate: 48000 }),
@@ -226,6 +252,8 @@ async function testCloseResolvesSpeech() {
   await testIdleTimeout();
   await testIdleBargeInKeepsCall();
   await testMaxDuration();
+  await testJoinRetriesNoSuchRoom();
+  await testJoinGivesUpAfterRetries();
   await testCloseResolvesSpeech();
   console.log("kazee call session: ok");
 })().catch((error) => { console.error(error); process.exitCode = 1; });

package/test-provider-enforcer.js

@@ -95,7 +95,10 @@ async function providerProbe(kind) {
   const service = enforcer.createEnforcerService({
     spawnUtilityAgent: utility.spawnUtilityAgent,
     audit,
-    timeoutMs: 2000,
+    // Generous: children answer in ms, so the green path never waits this out.
+    // The deadline exists only as the fail-closed backstop, and 2000ms was
+    // missed by child boot on a loaded CI runner (pipeline 10445 flake).
+    timeoutMs: 8000,
   });
   const speaker = { name: "External Fixture", relationship: "external", mandate: "May discuss invoice status only." };
   const secret = ["sk", "proj", "guard", "fixture", "private"].join("-");
@@ -106,9 +109,10 @@ async function providerProbe(kind) {
   const timeoutService = enforcer.createEnforcerService({
     spawnUtilityAgent: utility.spawnUtilityAgent,
     audit,
-    // 2500ms so the hung child boots on a loaded CI runner (writing capture #5
-    // and arming its SIGTERM recorder) before the deadline fires.
-    timeoutMs: 2500,
+    // Bounded (this deadline MUST fire — the child hangs by design), but with
+    // enough headroom for the hung child to boot on a loaded CI runner (write
+    // capture #5, arm its SIGTERM recorder) before the deadline kills it.
+    timeoutMs: 5000,
   });
   const timedOut = await timeoutService.vetReply(speaker, "timeout verdict fixture");
 

package/test-provider-language.js

@@ -212,7 +212,22 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // 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");
+// 3.1.15 approved by Sumeet 2026-07-22 ("if replying in voice it needs to be
+// summaries etc but not just conversions directly"): voice-note replies now
+// speak a provider-written conversational <voice-script> summary (stripped from
+// the chat text) instead of a verbatim TTS of the formatted answer, with a
+// sanitizing speechFallback when the script is missing.
+// 3.1.16 approved by Sumeet 2026-07-22 (same calls-directive authority; re-cut
+// of the never-published 3.1.15 after two loaded-runner CI flakes): test-only
+// deflake — heal-guard test stubs its live api.telegram.org probe and isolates
+// CONFIG_DIR; enforcer probe deadlines raised to CI-safe values (2000→8000ms
+// backstop, 2500→5000ms deliberate-timeout boot headroom). No runtime changes.
+// 3.1.17 approved by Sumeet 2026-07-23 (same calls-directive authority; his web
+// call to an upgraded bot showed "Call declined"): the call bridge now retries
+// the Janus publisher join through transient 426 "No such room" — the caller
+// creates the room at dial time and the bot answers faster than any human, so
+// the single naked join lost the race deterministically.
+assert.strictEqual(pkg.version, "3.1.17", "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}`);
 }