@inetafrica/open-claudia 3.4.13 → 3.4.15

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 3.4.15
+
+- Preserve complete Kazee speech turns with protocol-2 segment matching, bounded pending finals, and cancellation when speech resumes during an endpoint decision. Keep compatibility with older speech servers, including a delayed protocol-ready message.
+- Stop obsolete speech and remove superseded queued call turns on interruption or hangup. Use a fresh provider conversation with bounded spoken history while preserving identity, policy and recall. In-progress tools continue under their existing lifecycle.
+- Add `open-claudia call-say` for explicit complete answer sentences before the provider finishes. Each request is bound to the active call and run, redacted, and checked by the outbound reply guard. Retries are idempotent; final delivery removes the exact prefix already spoken. Provider previews and reasoning remain unspoken; this does not add token streaming to the provider transport.
+- Replace repeated thinking sounds with optional delayed fixed cues from the separate speech controller. Endpoint and cue models require the corresponding speech-service deployment; model quality, live latency and Android acceptance remain separate verification gates.
+- Isolate permission-test fixtures from inherited test-launcher approval without changing production permission gates.
+
+## 3.4.14
+
+- Subscribe to managed call audio only when gateway-authenticated publisher metadata identifies a User. Exclude bots, the current bot's other feeds, and missing or malformed classifications before creating subscriber connections or speech streams.
+- Preserve metadata through the initial room response and live publisher events. Managed calls use that authenticated classification; legacy calls retain their existing display-prefix exclusion because client-supplied metadata is untrusted.
+- Exercise the actual session subscription and offer/answer path for allowed users and rejected bot, self and unknown feeds.
+
 ## 3.4.13
 
 - **Codex is now measured the way Claude is.** After each Codex turn the bot reads Codex's own per-request token log (`$CODEX_HOME/sessions/…/rollout-*-<thread>.jsonl`) and uses the last request's size as the live context, instead of the turn's input summed over every tool call. That sum (33M on one turn) tripped auto-compact after almost every substantial Codex turn — 8 needless compactions on 2026-09-05, each a summary run plus a cold restart — while Codex's real window occupancy never exceeded 245k of its 258k window. Codex sessions now compact at 80% of the window Codex reports.

package/bin/cli.js

@@ -277,6 +277,33 @@ switch (command) {
     break;
   }
 
+  case "call-say": {
+    if (args[1] === "--help" || args[1] === "-h") {
+      console.log("Usage: open-claudia call-say [--id <request-id>] <text>\nOr: open-claudia call-say [--id <request-id>] --stdin\nSpeak one checked 1–450 character chunk into the current call turn. Wait for completion; reuse an ID only when retrying identical text.");
+      break;
+    }
+    const parts = args.slice(1);
+    let requestId = require("crypto").randomUUID();
+    if (parts[0] === "--id") { parts.shift(); requestId = parts.shift(); }
+    const text = parts.length === 1 && parts[0] === "--stdin"
+      ? require("fs").readFileSync(0, "utf8").trim() : parts.join(" ").trim();
+    if (!text || text.length > 450 || !/^[A-Za-z0-9_-]{1,80}$/.test(requestId || "")) {
+      console.error("Provide a valid request ID and 1–450 characters of spoken text.");
+      process.exit(2);
+    }
+    (async () => {
+      try {
+        const result = await require("./loopback-client").postJson("call-say", { text, requestId });
+        if (result.ok !== true || result.spoken !== true) throw new Error("Speech was not completed");
+        console.log(result.duplicate ? "Already spoken." : "Spoken.");
+      } catch (error) {
+        console.error(error.message);
+        process.exitCode = 1;
+      }
+    })();
+    break;
+  }
+
   case "say": {
     // Agents probe with --help before speaking; don't synthesize the flag.
     if (args[1] === "--help" || args[1] === "-h") {
@@ -563,6 +590,7 @@ Send tools (only work inside an active bot-spawned task):
   open-claudia send-photo <path> [caption]
   open-claudia send-voice <path>
   open-claudia say "<text>"          Synthesize the text (TTS) and send it as a voice note
+  open-claudia call-say "<text>"     Speak a checked sentence into the active call turn
   open-claudia tts "<text>" --out <path>     Synthesize to a FILE without sending (voice-overs,
                                              narration; ext picks format; --voice <id> optional)
   open-claudia transcribe <file>     Speech-to-text: print the transcript of an audio/video file

package/bin/loopback-client.js

@@ -75,6 +75,7 @@ function postJson(kind, body) {
   const sameProject = !ctx.project || !requestedProject || requestedProject === ctx.project;
   const payload = JSON.stringify({
     ...body,
+    ...(kind === "call-say" ? { callSpeechToken: process.env.OC_CALL_SPEECH_TOKEN || "" } : {}),
     channelId: ctx.channelId,
     adapter: ctx.adapterId,
     userId: ctx.userId,

package/channels/kazee/call/manager.js

@@ -86,13 +86,21 @@ class KazeeCallManager {
   }
 
   _sessionEnded(session, reason) {
+    // Several terminal paths clear this.session before close() calls back.
+    // Invalidate the closed call's work even when it no longer owns the slot.
+    session?._voiceTurn?.controller.abort("call-ended");
     if (this.session !== session) return;
-    this.session = null;
+    this._detachSession(session);
     if (this.adapter._socket?.connected) this.adapter._socket.emit("call:end", {
       ...session.callIdentity, chatId: session.chatId, toUserId: session.callerId, reason,
     });
   }
 
+  _detachSession(session) {
+    session?._voiceTurn?.controller.abort("call-ended");
+    if (this.session === session) this.session = null;
+  }
+
   _manageLease(session, access) {
     if (!access) return;
     const socket = this.adapter._socket;
@@ -103,7 +111,7 @@ class KazeeCallManager {
       if (this.session !== session || session.closed) return;
       console.warn(`Kazee managed call lease ${reason}`);
       socket.emit("call:end", { ...session.callIdentity, deviceId: this.deviceId, chatId: session.chatId, toUserId: session.callerId, reason: "network-timeout" });
-      this.session = null;
+      this._detachSession(session);
       session.close(`lease-${reason}`).catch(() => console.error("Kazee call lease cleanup failed"));
     }, access.leaseExpiresAt, randomUUID);
   }
@@ -141,7 +149,8 @@ class KazeeCallManager {
       const boundIdentity = access ? { ...publicCallIdentity(access), deviceId: this.deviceId, generation: access.generation } : identity;
       session = new this.SessionImpl({ roomId, chatId, callerId, botUserId: this.adapter.botUserId,
         ...this._sessionOptions(config, access, boundIdentity, pending.controller.signal), greeting: INCOMING_GREETING,
-        onTranscript: (text, meta) => this._transcript(text, { ...payload, ...boundIdentity }, meta),
+        onTranscript: (text, meta) => this._transcript(text, { ...payload, ...boundIdentity }, meta, session),
+        onSpeechStart: () => this._speechStart(session),
         onMediaReady: () => this._mediaReady(session),
         onEnded: reason => { session?._leaseHeartbeat?.close(); pending.controller.abort(); this._sessionEnded(session, reason); },
       });
@@ -156,7 +165,7 @@ class KazeeCallManager {
       if (session._mediaReady) session._leaseHeartbeat?.activate();
     } catch (_) {
       const cancelled = pending.controller.signal.aborted;
-      if (this.session === session) this.session = null;
+      this._detachSession(session);
       if (session) await session.close("connect-failed").catch(() => {});
       if (!cancelled) reject("connection_failed");
     } finally { if (this._pending === pending) this._pending = null; }
@@ -187,7 +196,8 @@ class KazeeCallManager {
       const remote = { ...identity, chatId: chat, fromUserId: target, fromUserName: "" };
       session = new this.SessionImpl({ roomId, chatId: chat, callerId: target, botUserId: this.adapter.botUserId,
         ...this._sessionOptions(config, access, identity, pending.controller.signal), asCaller: true, greeting: OUTGOING_GREETING,
-        onTranscript: (text, meta) => this._transcript(text, remote, meta),
+        onTranscript: (text, meta) => this._transcript(text, remote, meta, session),
+        onSpeechStart: () => this._speechStart(session),
         onMediaReady: () => this._mediaReady(session),
         onEnded: reason => { session?._leaseHeartbeat?.close(); pending.controller.abort(); this._clearRingTimer(); this._sessionEnded(session, reason); },
       });
@@ -202,7 +212,7 @@ class KazeeCallManager {
       this._ringTimer.unref?.();
       return { ...identity, chatId: chat, toUserId: target };
     } catch (error) {
-      if (this.session === session) this.session = null;
+      this._detachSession(session);
       if (session) await session.close("connect-failed").catch(() => {});
       throw error;
     } finally { if (this._pending === pending) this._pending = null; }
@@ -223,7 +233,7 @@ class KazeeCallManager {
     // Caller hanging up while ringing: chat-central finalizes the CallLog as
     // missed and dismisses the callee's ringing UI/push.
     this.adapter._socket?.emit("call:end", { ...session.callIdentity, toUserId, chatId });
-    this.session = null;
+    this._detachSession(session);
     await session.close("no-answer").catch(() => {});
   }
 
@@ -231,23 +241,65 @@ class KazeeCallManager {
     if (this._ringTimer) { clearTimeout(this._ringTimer); this._ringTimer = null; }
   }
 
-  _transcript(text, incoming, meta = {}) {
+  _speechStart(session) {
+    if (session?._voiceTurn) session._voiceTurn.muted = true;
+    // Sound alone is not a new request. Cancel queued work only once a new
+    // complete transcript exists; a cough must not discard an accepted ask.
+  }
+
+  _rememberSpeech(session, role, text) {
+    const history = session._voiceHistory ||= [];
+    if (role === "assistant" && history.at(-1)?.role === "assistant") {
+      history.at(-1).text = `${history.at(-1).text} ${text}`.slice(-6000);
+    } else history.push({ role, text: String(text).slice(-6000) });
+    while (history.length > 8 || history.reduce((size, entry) => size + entry.text.length, 0) > 12000) history.shift();
+  }
+
+  _transcript(text, incoming, meta = {}, sourceSession = this.session) {
     const session = this.session;
-    if (!session || !text) return;
+    if (!session || session.closed || sourceSession !== session || !text) return;
     // In a group room, tell the provider who is talking; 1:1 stays unprefixed.
     const speaker = String(meta.display || "").trim();
     const attributed = (meta.participants || 0) > 1 && speaker ? `${speaker}: ${text}` : text;
+    session._voiceTurn?.controller.abort("superseded");
+    const turn = { controller: new AbortController(), muted: false };
+    session._voiceTurn = turn;
     const callAdapter = Object.create(this.adapter);
+    callAdapter.callHistory = (session._voiceHistory || []).map(entry => ({ ...entry }));
+    callAdapter.callTurn = { signal: turn.controller.signal };
+    this._rememberSpeech(session, "user", attributed);
     // Provider narration/previews are useful in chat but must never be spoken
-    // into a call. Only the settled, guarded final answer reaches send().
+    // into a call. send() receives settled answers; explicit sentence speech
+    // enters separately through the call-turn lease and outbound reply guard.
     callAdapter.suppressStreamPreview = true;
     // Recall/tooltrace banners route through the same send() as the answer —
     // without this flag the TTS reads memory-debug lines to the caller.
     callAdapter.suppressChatVisibility = true;
     // Prompt builder switches to phone-call brevity when it sees this.
     callAdapter.liveCall = true;
+    const spokenSentences = [];
+    callAdapter.isCallTurnActive = () => !turn.muted && !turn.controller.signal.aborted &&
+      !session.closed && this.session === session && session._voiceTurn === turn;
+    callAdapter.cancelCallSpeech = () => {
+      if (this.session === session && session._voiceTurn === turn) session.cancelSpeech();
+    };
+    const speak = async response => {
+      if (!callAdapter.isCallTurnActive()) return false;
+      const spoken = await session.speak(response);
+      if (spoken !== false && callAdapter.isCallTurnActive()) {
+        this._rememberSpeech(session, "assistant", response);
+        return true;
+      }
+      return false;
+    };
+    callAdapter.speakSentence = async response => {
+      const spoken = await speak(response);
+      if (spoken) spokenSentences.push(response);
+      return spoken;
+    };
     callAdapter.send = async (_channelId, response) => {
-      await session.speak(response);
+      const remainder = require("../../../core/call-speech").unspokenSuffix(response, spokenSentences);
+      if (remainder) await speak(remainder);
       return true;
     };
     callAdapter.edit = async () => true;
@@ -275,7 +327,7 @@ class KazeeCallManager {
     if (payload.roomId != null && Number(payload.roomId) !== this.session.roomId) return;
     // Terminal server state is authoritative; ended attempts are never revived.
     const session = this.session;
-    this.session = null;
+    this._detachSession(session);
     await session.close("remote-ended");
   }
 
@@ -283,7 +335,7 @@ class KazeeCallManager {
     if (!this.session || !this._matches(payload)) return;
     if (payload.roomId != null && Number(payload.roomId) !== this.session.roomId) return;
     const session = this.session;
-    this.session = null;
+    this._detachSession(session);
     await session.close("remote-rejected");
   }
 
@@ -292,7 +344,7 @@ class KazeeCallManager {
     this._clearRingTimer();
     if (!this.session) return;
     const session = this.session;
-    this.session = null;
+    this._detachSession(session);
     await session.close("adapter-stopped");
   }
 }