@inetafrica/open-claudia 3.4.13 → 3.4.15

package/test-kazee-call-speech.js

@@ -2,7 +2,7 @@
 "use strict";
 const assert = require("assert");
 const { EventEmitter } = require("events");
-const { SpeechStream, synthesizePcm } = require("./channels/kazee/call/speech-client");
+const { SpeechStream, synthesizePcm, detectTurn, selectAcknowledgement } = 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")); }
@@ -14,12 +14,32 @@ class FakeWebSocket extends EventEmitter {
   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" });
+  assert.deepStrictEqual(JSON.parse(stream.socket.sent[0]), { sample_rate: 16000, language: "en", protocol: 2 });
   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");
+  const finals = [], partials = [];
+  const versioned = new SpeechStream({ baseUrl: "https://speech.example", token: "secret", WebSocketImpl: FakeWebSocket,
+    onTranscript: (text, meta) => finals.push({ text, meta }), onPartial: (text, meta) => partials.push({ text, meta }) });
+  await versioned.connect();
+  const oldSocket = versioned.socket;
+  oldSocket.emit("message", Buffer.from(JSON.stringify({ type: "ready", protocol: 2, segment_id: 1 })));
+  const first = versioned.commitTurn(), second = versioned.commitTurn();
+  await Promise.all([first.pending, second.pending]);
+  assert.deepStrictEqual(oldSocket.sent.slice(1).map(JSON.parse), [{ type: "commit", segment_id: 1 }, { type: "commit", segment_id: 2 }]);
+  oldSocket.emit("message", Buffer.from(JSON.stringify({ type: "final", segment_id: 1, text: "" })));
+  assert.strictEqual(finals.length, 1, "empty final is forwarded to clear the committed turn");
+  assert.strictEqual(finals[0].meta.segmentId, 1);
+  oldSocket.close();
+  assert.strictEqual(versioned.protocol, 1, "disconnect resets protocol before a new turn can commit");
+  await versioned.connect();
+  oldSocket.emit("message", Buffer.from(JSON.stringify({ type: "final", segment_id: 2, text: "stale" })));
+  assert.strictEqual(finals.length, 1, "an old socket cannot deliver into a new stream");
+  assert.strictEqual(versioned.segmentId, 1);
+  versioned.close();
+  await assert.rejects(versioned.audio(Buffer.alloc(2)), /closed/, "terminal close cannot reopen a speech connection");
   let request;
   const pcm = await synthesizePcm("Hello", { baseUrl: "https://speech.example", token: "secret", fetchImpl: async (url, options) => {
     request = { url, options }; return {
@@ -31,6 +51,22 @@ class FakeWebSocket extends EventEmitter {
   assert.strictEqual(JSON.parse(request.options.body).response_format, "pcm");
   assert.strictEqual(pcm.sampleRate, 24000);
   assert.deepStrictEqual([...pcm.pcm], [1, 2, 3]);
+  const controller = { baseUrl: "https://speech.example", token: "fixture", fetchImpl: async (_url, options) => {
+    assert.strictEqual(JSON.parse(options.body).state, "waiting");
+    return { ok: true, json: async () => ({ choice: "wait", text: "Invented answer must never be spoken" }) };
+  } };
+  assert.strictEqual(await selectAcknowledgement("A complete question", "waiting", controller), "One moment.");
+  assert.strictEqual(await selectAcknowledgement("hello", "working", { ...controller,
+    fetchImpl: async () => ({ ok: true, json: async () => ({ choice: "acknowledge", text: "Mhm." }) }),
+  }), "", "wrong-state cue is omitted");
+  await assert.rejects(detectTurn(Buffer.alloc(640), { ...controller,
+    fetchImpl: async () => ({ ok: true, json: async () => ({ complete: true, probability: 3 }) }),
+  }), /Invalid turn decision/);
+  const abort = new AbortController();
+  abort.abort();
+  await assert.rejects(synthesizePcm("cancelled", { baseUrl: "https://speech.example", token: "fixture", signal: abort.signal,
+    fetchImpl: async (_url, options) => { assert(options.signal.aborted); throw new Error("aborted"); },
+  }), /aborted/, "TTS request inherits call cancellation");
   stream.close();
   console.log("kazee call speech: ok");
 })().catch((error) => { console.error(error); process.exitCode = 1; });

package/test-provider-env-isolation.js

@@ -85,6 +85,11 @@ assert.throws(
 );
 
 const base = baseAgentEnv(source);
+for (const builder of [baseAgentEnv, claudeAgentEnv, codexAgentEnv]) {
+  assert.strictEqual(builder({ ...source, OC_CALL_SPEECH_TOKEN: "stale-call-capability",
+    AGENT_ENV_PASSTHROUGH: "OC_CALL_SPEECH_TOKEN" }).OC_CALL_SPEECH_TOKEN, undefined,
+  "a call speech capability never passes through a generic provider environment");
+}
 assert.strictEqual(base.PROJECT_REGION, "fixture-region", "explicit project passthrough survives");
 assert.deepStrictEqual(presence(base), Object.fromEntries(baseline.environment.keys.map((key) => [key, false])));
 

package/test-provider-gateway.js

@@ -382,7 +382,7 @@ async function schedulerProbe() {
   console.log("provider gateway scheduler OK");
 }
 
-function queueProbe() {
+async function queueProbe() {
   const projectA = path.join(process.env.WORKSPACE, "project-a");
   const projectB = path.join(process.env.WORKSPACE, "project-b");
   fs.mkdirSync(projectA, { recursive: true });
@@ -455,6 +455,20 @@ function queueProbe() {
   assert.strictEqual(queued.runContext.project.dir, projectA);
   assert.strictEqual(queued.runContext.providerSettings.model, "claude-fixture");
   assert.strictEqual(queued.runContext.sessionId, "claude-queued-session");
+  const obsoleteCall = new AbortController();
+  store.adapter.liveCall = true;
+  store.adapter.callTurn = { signal: obsoleteCall.signal };
+  const callPending = runAgent("obsolete call question", projectA, null, { runId: "obsolete-call" });
+  assert.strictEqual(state.messageQueue.length, 2);
+  obsoleteCall.abort();
+  assert.strictEqual(state.messageQueue.length, 1, "superseded call entry is removed immediately, ordinary queued work is preserved");
+  assert.strictEqual((await callPending).status, "cancelled");
+  assert.strictEqual(state.messageQueue[0], queued);
+  const alreadyEnded = await runAgent("late call dispatch", projectA, null, { runId: "late-call" });
+  assert.strictEqual(alreadyEnded.status, "cancelled");
+  assert.strictEqual(state.messageQueue.length, 1, "an already-ended call never joins the queue");
+  delete store.adapter.callTurn;
+  delete store.adapter.liveCall;
   console.log("provider gateway immutable queue OK");
 }
 

package/test-provider-language.js

@@ -464,9 +464,11 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // tool_name "Bash" and the deny gate caught the probe, so the gate no longer
 // requires unified_exec off. Push approved by Sumeet before release.
 // 3.4.12: Sumeet approved the full calling rollout on 2026-09-05; preserve assigned media configuration across canary changes.
+// 3.4.14: bot managed-call consumer (subscribe only to gateway-authenticated User publishers) — part of the Janus calling plan Sumeet approved on 2026-09-05.
 // 3.4.13: Codex usage accounting fix — Sumeet approved the three-bug fix on 2026-09-05 ("Yes");
 // prepared 2026-09-06 for his release go. Rollout-based Codex context, per-turn ledger, sub-agent + quota accounting.
-assert.strictEqual(pkg.version, "3.4.13", "release version must remain unchanged without explicit approval");
+// 3.4.15: conversation flow and checked sentence speech; authorized calling rollout, 2026-09-05/06.
+assert.strictEqual(pkg.version, "3.4.15", "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}`);
 }

package/test-provider-prompt-parity.js

@@ -30,7 +30,17 @@ async function probe() {
       origin: { transport: "telegram", channelId: "parity-channel" },
     },
   });
-  process.stdout.write(`${JSON.stringify({ bundle })}\n`);
+  const { chatContext } = require("./core/context");
+  const voiceBundle = await chatContext.run({ adapter: { type: "kazee", liveCall: true }, channelId: "parity-channel", canonicalUserId: state.userId }, () => buildTurnPrompt("Explain that beep.", {
+    provider: getProvider("codex"),
+    runContext: {
+      canonicalUserId: state.userId, project: { ...state.currentSession }, provider: "codex",
+      providerSettings: { ...state.settings }, sessionId: null, fresh: true, liveCall: true,
+      channelId: "parity-channel", origin: { transport: "kazee", channelId: "parity-channel" },
+      callHistory: [{ role: "user", text: "I heard a beep before you answered." }],
+    },
+  }));
+  process.stdout.write(`${JSON.stringify({ bundle, voiceBundle })}\n`);
 }
 
 if (process.argv[2] === "--probe") {
@@ -77,6 +87,11 @@ if (process.argv[2] === "--probe") {
     assert.ok(observed.bundle.dynamicContext.includes("## Project Transcript Memory"));
     assert.ok(observed.bundle.dynamicContext.includes("Codex exposes its native exec tools"));
     assert.ok(observed.bundle.recallMetadata);
+    assert.strictEqual(observed.voiceBundle.coreInstructions, observed.bundle.coreInstructions, "bounded call conversation keeps the complete core policy");
+    assert.ok(observed.voiceBundle.dynamicContext.includes("LIVE VOICE CALL"));
+    assert.ok(observed.voiceBundle.dynamicContext.includes("I heard a beep before you answered."));
+    assert.ok(observed.voiceBundle.dynamicContext.includes("Do not claim an earlier request was acted on without tool evidence."));
+    assert.strictEqual(observed.voiceBundle.userPrompt, "Explain that beep.");
     assert.notStrictEqual(
       `${observed.bundle.dynamicContext}\n\n${observed.bundle.userPrompt}`,
       baseline.prompt.sentinel,

package/test-provider-runner.js

@@ -132,6 +132,40 @@ async function main() {
     codex: path.join(root, "codex-capture.json"),
   };
   const providers = makeProviders(captures);
+  const voiceStore = { adapter: { liveCall: true, callHistory: [{ role: "user", text: "What about the beeping?" }] } };
+  mutable.activeSessions["project-a"].claude = "long-coding-session";
+  const voiceContext = captureRunContext({ state: mutable, store: voiceStore, prompt: "What does it mean?", cwd: projectA,
+    opts: { resumeSessionId: "long-coding-session", continueSession: true } });
+  assert.strictEqual(voiceContext.sessionId, null, "call must not resume the room's coding conversation");
+  assert.strictEqual(voiceContext.resumeSessionId, null);
+  assert.strictEqual(voiceContext.continueSession, false);
+  assert.strictEqual(voiceContext.fresh, true);
+  assert.strictEqual(voiceContext.attachSession, false, "call completion must not replace the coding session");
+  assert.strictEqual(voiceContext.skipAutoCompact, true, "call cannot compact the room's coding session");
+  voiceStore.adapter.callHistory[0].text = "later mutation";
+  assert.strictEqual(voiceContext.callHistory[0].text, "What about the beeping?", "queued history is immutable");
+  assert.ok(Object.isFrozen(voiceContext.callHistory[0]));
+  delete mutable.activeSessions["project-a"].claude;
+
+  let callObsolete = false;
+  let callBuilds = 0;
+  let callSpawns = 0;
+  const callGate = deferred();
+  const cancellableCall = createRunnerService({
+    getState: () => mutable,
+    getStore: () => voiceStore,
+    resolveProvider: id => providers[id],
+    isObsolete: () => callObsolete,
+    async buildTurnPrompt(prompt, opts) { callBuilds++; await callGate.promise; return simpleBundle(prompt, opts); },
+    spawnProcess() { callSpawns++; throw new Error("obsolete call must never spawn"); },
+  });
+  const preparingCall = cancellableCall.runAgent("old question", projectA, null);
+  callObsolete = true;
+  callGate.resolve();
+  assert.strictEqual((await preparingCall).status, "cancelled", "hangup during recall prevents provider execution");
+  assert.strictEqual(callSpawns, 0);
+  assert.strictEqual((await cancellableCall.runAgent("late dispatch", projectA, null)).status, "cancelled");
+  assert.strictEqual(callBuilds, 1, "obsolete call avoids even a prompt/recall build");
   const persisted = [];
   const delivered = [];
   const service = createRunnerService({

package/test-tool-manifest.js

@@ -16,6 +16,9 @@ process.env.APPROVALS_DIR = path.join(tmp, "approvals");
 const tools = require("./core/tools");
 const repo = require("./core/tool-repo");
 const approvals = require("./core/approvals");
+// The runner may itself be an approved composing tool. These fixtures model
+// top-level calls; keep process.env intact and inject each scenario explicitly.
+const topLevelEnv = {};
 
 (async () => {
   // ── scaffold with --verbs → manifest header lines, dispatcher, TOOL.md block ──
@@ -39,32 +42,32 @@ const approvals = require("./core/approvals");
   assert.ok(/list\)/.test(t.content) && /purge\)/.test(t.content), "bash dispatcher has a case per verb");
 
   // ── per-verb gate: tier comes from the invoked verb, not the tool tier ──
-  assert.strictEqual(tools.runGate(t, ["list"]).ok, true, "read-only verb runs unflagged");
-  assert.strictEqual(tools.runGate(t, ["list"]).tier, "read-only");
-  assert.strictEqual(tools.runGate(t, ["restart", "n1"]).ok, false, "write verb demands --yes");
-  assert.strictEqual(tools.runGate(t, ["restart", "n1", "--yes"]).ok, true);
-  assert.strictEqual(tools.runGate(t, ["purge", "n1", "--yes"]).ok, false, "--yes cannot approve a destructive verb");
-  const purgeGate = tools.runGate(t, ["purge", "n1"]);
+  assert.strictEqual(tools.runGate(t, ["list"], topLevelEnv).ok, true, "read-only verb runs unflagged");
+  assert.strictEqual(tools.runGate(t, ["list"], topLevelEnv).tier, "read-only");
+  assert.strictEqual(tools.runGate(t, ["restart", "n1"], topLevelEnv).ok, false, "write verb demands --yes");
+  assert.strictEqual(tools.runGate(t, ["restart", "n1", "--yes"], topLevelEnv).ok, true);
+  assert.strictEqual(tools.runGate(t, ["purge", "n1", "--yes"], topLevelEnv).ok, false, "--yes cannot approve a destructive verb");
+  const purgeGate = tools.runGate(t, ["purge", "n1"], topLevelEnv);
   assert.strictEqual(purgeGate.tier, "destructive", "failed gate reports the resolved tier for the approval fallback");
-  assert.strictEqual(tools.runGate(t, ["purge", "n1", "--yes-destructive"]).ok, true);
+  assert.strictEqual(tools.runGate(t, ["purge", "n1", "--yes-destructive"], topLevelEnv).ok, true);
 
   // ── undeclared verb on a manifest tool is refused regardless of flags ──
-  const un = tools.runGate(t, ["obliterate", "--yes-destructive"]);
+  const un = tools.runGate(t, ["obliterate", "--yes-destructive"], topLevelEnv);
   assert.strictEqual(un.ok, false, "undeclared verb refused");
   assert.strictEqual(un.undeclared, true);
   assert.ok(/no declared verb "obliterate"/.test(un.message));
 
   // ── help / no verb = read-only ──
-  assert.strictEqual(tools.runGate(t, []).ok, true, "no verb (help) runs unflagged");
-  assert.strictEqual(tools.runGate(t, ["help"]).tier, "read-only");
+  assert.strictEqual(tools.runGate(t, [], topLevelEnv).ok, true, "no verb (help) runs unflagged");
+  assert.strictEqual(tools.runGate(t, ["help"], topLevelEnv).tier, "read-only");
 
   // ── manifest-less tools keep the old whole-tool gate (backward compatible) ──
   const legacySrc = path.join(tmp, "old.sh");
   fs.writeFileSync(legacySrc, "#!/usr/bin/env bash\necho old\n");
   const legacy = tools.addTool(legacySrc, { name: "old", description: "legacy", risk: "write" });
   assert.strictEqual(legacy.manifest.length, 0);
-  assert.strictEqual(tools.runGate(legacy, ["anything"]).ok, false, "manifest-less write tool still needs --yes");
-  assert.strictEqual(tools.runGate(legacy, ["anything", "--yes"]).ok, true, "…and any verb is allowed with it");
+  assert.strictEqual(tools.runGate(legacy, ["anything"], topLevelEnv).ok, false, "manifest-less write tool still needs --yes");
+  assert.strictEqual(tools.runGate(legacy, ["anything", "--yes"], topLevelEnv).ok, true, "…and any verb is allowed with it");
 
   // ── nested composition still gates on the inherited tier, per verb ──
   const env = { OPEN_CLAUDIA_TOOL_STACK: "outer", OPEN_CLAUDIA_APPROVED_TIER: "write" };
@@ -119,6 +122,12 @@ const approvals = require("./core/approvals");
   approvals.decide(b10rec.id, "approved", "c1");
   const errs = [];
   const realErr = console.error;
+  // This integration fixture redeems a top-level approval against the isolated
+  // tools/keyring above. A nested tool must refuse redemption, so temporarily
+  // model the top-level CLI environment and restore the launcher's context.
+  const approvalKeys = ["OPEN_CLAUDIA_TOOL_STACK", "OPEN_CLAUDIA_APPROVED_TIER"];
+  const savedApprovalEnv = Object.fromEntries(approvalKeys.map((key) => [key, process.env[key]]));
+  for (const key of approvalKeys) delete process.env[key];
   console.error = (...a) => errs.push(a.join(" "));
   try {
     process.exitCode = 0;
@@ -134,6 +143,10 @@ const approvals = require("./core/approvals");
     assert.strictEqual(process.exitCode, 0, "the same token redeems once the key exists");
     assert.ok(approvals.read(b10rec.id).consumedAt, "token consumed exactly by the real run");
   } finally {
+    for (const key of approvalKeys) {
+      if (savedApprovalEnv[key] === undefined) delete process.env[key];
+      else process.env[key] = savedApprovalEnv[key];
+    }
     console.error = realErr;
     process.exitCode = 0;
   }

package/test-tools.js

@@ -250,14 +250,18 @@ assert.strictEqual(tools.findTool("hello").createdAt, bornHello, "createdAt is i
 
 // ── runGate: read-only runs freely; write demands --yes; destructive demands
 //    --yes-destructive (a plain --yes must NOT unlock it); undeclared → write ──
-assert.ok(tools.runGate({ name: "t", risk: "read-only" }, []).ok, "read-only runs without flags");
-assert.ok(!tools.runGate({ name: "t", risk: "write" }, []).ok, "write without --yes is refused");
-assert.ok(tools.runGate({ name: "t", risk: "write" }, ["--yes"]).ok, "write with --yes runs");
-assert.ok(!tools.runGate({ name: "t", risk: "destructive" }, ["--yes"]).ok, "plain --yes does not unlock destructive");
-assert.ok(tools.runGate({ name: "t", risk: "destructive" }, ["--yes-destructive"]).ok, "destructive with --yes-destructive runs");
-const undeclared = tools.runGate({ name: "t", risk: "" }, []);
+// These fixtures model top-level invocations even when npm test is launched
+// through an approved tool. Keep the real process approval environment intact;
+// nested composition is exercised with explicit environments below.
+const topLevelEnv = {};
+assert.ok(tools.runGate({ name: "t", risk: "read-only" }, [], topLevelEnv).ok, "read-only runs without flags");
+assert.ok(!tools.runGate({ name: "t", risk: "write" }, [], topLevelEnv).ok, "write without --yes is refused");
+assert.ok(tools.runGate({ name: "t", risk: "write" }, ["--yes"], topLevelEnv).ok, "write with --yes runs");
+assert.ok(!tools.runGate({ name: "t", risk: "destructive" }, ["--yes"], topLevelEnv).ok, "plain --yes does not unlock destructive");
+assert.ok(tools.runGate({ name: "t", risk: "destructive" }, ["--yes-destructive"], topLevelEnv).ok, "destructive with --yes-destructive runs");
+const undeclared = tools.runGate({ name: "t", risk: "" }, [], topLevelEnv);
 assert.ok(!undeclared.ok && undeclared.tier === "write", "undeclared tier is treated as write (fail-safe)");
-assert.ok(/destructive/i.test(tools.runGate({ name: "t", risk: "destructive" }, []).message), "destructive refusal spells out the warning");
+assert.ok(/destructive/i.test(tools.runGate({ name: "t", risk: "destructive" }, [], topLevelEnv).message), "destructive refusal spells out the warning");
 
 // ── scaffold: creates dir + stub + TOOL.md, registered and runnable ──
 const sc = repo.scaffoldTool("kwidget", { description: "widget system CLI", risk: "read-only", pack: "widgets", usage: "kwidget <verb>" });