@inetafrica/open-claudia 3.5.47 → 3.5.59

package/core/run-context.js

@@ -4,7 +4,7 @@ const crypto = require("crypto");
 const path = require("path");
 const { currentConversationKey, currentThreadId } = require("./context");
 const { resolveProviderSettings, peekLane } = require("./state");
-const { parseConversationKey } = require("./identity");
+const { parseConversationKey, callLaneKey } = require("./identity");
 
 function cloneSerializable(value, label = "run context value") {
   if (value === undefined) return undefined;
@@ -57,6 +57,26 @@ function projectSnapshot(state, cwd, requestedProject) {
 // whole main context in a session of its own. Default "fresh": a new thread
 // starts a new session, seeded only with the thread's own messages. Codex has
 // no fork, so it always starts fresh.
+// A live call answers in speech, so its turn may run a faster model and effort
+// than the room's chat turns: KAZEE_CALL_MODEL / KAZEE_CALL_EFFORT (Claude
+// only). Unset keeps the room's own settings; an unknown effort is ignored.
+const CALL_EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
+function callSetting(name) {
+  let value = process.env[name];
+  try { value = require("./config").config?.[name] ?? value; } catch (_) {}
+  return String(value || "").trim();
+}
+
+function callProviderOverrides(provider) {
+  if (provider !== "claude") return {};
+  const overrides = {};
+  const model = callSetting("KAZEE_CALL_MODEL");
+  const effort = callSetting("KAZEE_CALL_EFFORT").toLowerCase();
+  if (model) overrides.model = model;
+  if (CALL_EFFORTS.has(effort)) overrides.effort = effort;
+  return overrides;
+}
+
 function threadSeedMode() {
   let value = process.env.OC_THREAD_SEED;
   try { value = require("./config").config?.OC_THREAD_SEED ?? value; } catch (_) {}
@@ -127,8 +147,10 @@ function captureRunContext({
   const activeSessionId = state.activeSessions?.[project.name]?.[provider] || null;
   // The run's lane (its conversation: a thread is its own) and thread are
   // fixed here, at admission: queueing, /stop, preview, typing and delivery all
-  // follow the lane the message arrived in, never a later one.
-  const laneKey = String(opts.laneKey || currentConversationKey() || project.name || "Workspace");
+  // follow the lane the message arrived in, never a later one. A live call's
+  // turns get a lane of their own beside their chat's.
+  const conversationLane = String(opts.laneKey || currentConversationKey() || project.name || "Workspace");
+  const laneKey = liveCall ? callLaneKey(conversationLane) : conversationLane;
   const threadId = (store && store.threadId) || currentThreadId() || parseConversationKey(laneKey).threadId || null;
   const lane = peekLane(state, laneKey);
   const forkFromSessionId = threadForkSession(state, { provider, laneKey, threadId, activeSessionId, opts, liveCall });
@@ -154,6 +176,7 @@ function captureRunContext({
   // personal bucket, so non-room channels are unaffected.
   const providerSettings = cloneSerializable({
     ...(resolveProviderSettings(state, provider) || {}),
+    ...(liveCall ? callProviderOverrides(provider) : {}),
     ...(opts.providerSettings || {}),
   }, "provider settings");
   delete providerSettings.backend;
@@ -261,6 +284,7 @@ function bindRunInputs(runContext, inputs = {}) {
 }
 
 module.exports = {
+  projectSnapshot,
   captureRunContext,
   bindRunInputs,
   cloneSerializable,

package/core/runner.js

@@ -20,6 +20,7 @@ const {
   resolveProviderSettings, getProjectSessions,
 } = require("./state");
 const { chatContext, currentChannelId, currentAdapter, currentThreadId } = require("./context");
+const { isCallLaneKey } = require("./identity");
 const { buildTurnPrompt } = require("./system-prompt");
 const turnJournal = require("./turn-journal");
 const usageLimits = require("./usage-limits");
@@ -413,6 +414,11 @@ async function executeProviderInvocation(options = {}) {
       terminalSeen = true;
       if (event.sessionId) sessionId = event.sessionId;
       if (typeof event.text === "string" && event.text) resultText = event.text;
+      // The answer as it will be delivered (finalAnswerText, else the
+      // result's own text), known now: a live call speaks it before the
+      // process has exited (earlyCallAnswer below).
+      const segments = textSegments.map((blocks) => blocks.join("")).filter((t) => t.trim());
+      event.answerText = redactSensitive(String(segments.at(-1) || resultText || "").trim());
     } else if (event.type === "error") {
       terminalSeen = true;
       rawErrors.push(event);
@@ -1490,6 +1496,7 @@ function deriveCompactionRunContext(base, overrides = {}) {
     admittedSessionId: overrides.sessionId ?? null,
     previousSessionId: overrides.previousSessionId ?? base.sessionId ?? null,
     resumeSessionId: overrides.resumeSessionId ?? null,
+    forkSession: overrides.forkSession === true,
     continueSession: false,
     fresh: !!overrides.fresh,
     recallQuery: overrides.recallQuery ?? null,
@@ -1580,6 +1587,11 @@ function createCompactionService(dependencies = {}) {
       sessionId: oldSessionId,
       resumeSessionId: oldSessionId,
       previousSessionId: oldSessionId,
+      // Read the live conversation through a fork (Claude --fork-session): the
+      // summarize prompt and its brief must never land in the live session. A
+      // summary that fails (an OAuth refresh error, a timeout) would leave the
+      // prompt there, and the next turn answers it into the chat (12 Oct).
+      forkSession: true,
       fresh: false,
     });
     const operationId = opts.operationId || (typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `compact-${Date.now()}`);
@@ -1851,6 +1863,11 @@ function providerRunDiagnostic(result, runContext) {
 async function persistForegroundTranscript(result, runContext, state = currentState()) {
   const view = capturedStateView(state, runContext);
   const session = () => result.sessionId || runContext.sessionId || null;
+  // A run stopped on purpose did not fail: /stop, or a call job the quick
+  // voice answered itself or the caller replaced (stopCallRunWhenDropped).
+  // Its words are kept; a "run failed: exited with code 143" note is not
+  // (11 Oct: five such notes in one call's transcript).
+  const stopped = !result.ok && (result.error?.code === "RUN_CANCELLED" || cancelTargets(laneForRun(state, runContext).cancelRequested, runContext));
   appendProjectTranscript(
     runContext.transcriptRole || "user",
     stripTranscriptPointerForStorage(runContext.userPrompt),
@@ -1865,6 +1882,7 @@ async function persistForegroundTranscript(result, runContext, state = currentSt
     session,
     { strict: true },
   );
+  if (stopped) return;
   const role = result.ok ? "assistant" : "system-note";
   const text = result.ok
     ? (result.text || "(no output)")
@@ -2452,9 +2470,12 @@ function createForegroundService({ state, store, lane, stopTyping, capture, owns
   // another run then claimed) must not touch that lane's run slot.
   const holds = () => (holdsLane ? holdsLane() : ownsAdmissionLock);
   const callSpeechLeases = new Map();
+  const callStopListeners = new Map();
   const callStage = (stage, runContext) => {
     if (capture || runContext?.liveCall !== true) return;
     console.log(`${new Date().toISOString()} Kazee call provider: stage=${stage} run=${runContext.runId} elapsed=${Math.max(0, Date.now() - runContext.admittedAt)}ms`);
+    // The call's job board: this job is now the one being worked on.
+    try { store?.adapter?.onCallStage?.(stage); } catch (_) {}
   };
   const persistEffects = !capture || persistCapture;
   // The run's lane: given by executeAdmittedRun, else the captured run's own.
@@ -2502,6 +2523,10 @@ function createForegroundService({ state, store, lane, stopTyping, capture, owns
       if (ownsAdmissionLock) onOwnSpawn?.(proc);
       if (ownsAdmissionLock || !runLane.runningProcess) runLane.runningProcess = proc;
       if (ownsAdmissionLock) runLane.preparingRun = false;
+      if (!capture && ownsAdmissionLock) {
+        const remove = stopCallRunWhenDropped(store, runLane, proc, runContext);
+        if (remove) callStopListeners.set(runContext.runId, remove);
+      }
     },
     shouldAbort(runContext, { capture: isCapture } = {}) {
       if (isCapture || !ownsAdmissionLock) return false;
@@ -2535,6 +2560,23 @@ function createForegroundService({ state, store, lane, stopTyping, capture, owns
       if (observer && event.type === "tool_start" && runContext.purpose === "foreground") {
         try { observer.onToolStart(event.name, event.detail); } catch (_) {}
       }
+      // A live call's job board hears what the full agent is doing (tool
+      // steps), so the quick voice can answer "what's the status?".
+      if (!capture && runContext?.liveCall === true && event.type === "tool_start") {
+        try { store?.adapter?.onCallActivity?.(event); } catch (_) {}
+      }
+      // A live call hears the answer once it is written, not once the CLI has
+      // exited: its end-of-turn work took ~0.8 s on both answers of the 11 Oct
+      // 18:57 call. The normal delivery still runs after; the call skips the
+      // words it was already handed. Never for a guarded speaker (their reply
+      // goes through the outbound guard first).
+      if (!capture && runContext?.liveCall === true && event.type === "result" && event.answerText && !PLACEHOLDER_REPLY.test(event.answerText)) {
+        let guarded = true;
+        try { guarded = require("./relationship").isCurrentSpeakerGuarded(); } catch (_) {}
+        if (!guarded) {
+          try { Promise.resolve(store?.adapter?.earlyCallAnswer?.(event.answerText)).catch(() => {}); } catch (_) {}
+        }
+      }
       if (preview && event.type === "text_final" && typeof event.text === "string" && event.text) {
         preview.append(event.text, runContext);
       }
@@ -2552,6 +2594,8 @@ function createForegroundService({ state, store, lane, stopTyping, capture, owns
       try { require("./speaker-attest").endRun(runContext.runId); } catch (_) {}
       callSpeechLeases.get(runContext.runId)?.close();
       callSpeechLeases.delete(runContext.runId);
+      callStopListeners.get(runContext.runId)?.();
+      callStopListeners.delete(runContext.runId);
       const runLane = laneOf(runContext);
       if (runLane.runningProcess === proc) runLane.runningProcess = null;
       // Keep the lane's lock armed while transcript/usage/session persistence
@@ -2637,6 +2681,29 @@ function obsoleteCallTurn(store) {
   return store?.adapter?.liveCall === true && store.adapter.callTurn?.signal.aborted === true;
 }
 
+// A live-call turn the call dropped while its provider runs: the caller
+// changed their mind ("replaced"), the quick voice handled it alone ("self"),
+// or (with no quick voice) a newer utterance took over ("superseded"). Stop
+// it the way /stop does (named cancel flag, then the process tree), so it
+// neither holds the call's lane nor speaks. A turn whose call ENDED keeps
+// running, so "do X" said just before hanging up still gets done. Ported from
+// the 4 Oct calls build. Returns the listener's remover, or null.
+const STOPPED_CALL_TURN_REASONS = new Set(["superseded", "cancelled", "replaced", "self"]);
+function stopCallRunWhenDropped(store, lane, proc, runContext) {
+  const signal = runContext?.liveCall === true ? store?.adapter?.callTurn?.signal : null;
+  if (!signal || !proc?.pid) return null;
+  const stop = () => {
+    if (!STOPPED_CALL_TURN_REASONS.has(signal.reason) || lane.runningProcess !== proc) return;
+    lane.cancelRequested = runContext.runId || true;
+    console.log(`${new Date().toISOString()} Kazee call provider: stage=${signal.reason} run=${runContext.runId} elapsed=${Math.max(0, Date.now() - runContext.admittedAt)}ms`);
+    killProcessTree(proc.pid, "SIGTERM");
+    setTimeout(() => killProcessTree(proc.pid, "SIGKILL"), 3000).unref?.();
+  };
+  if (signal.aborted) { stop(); return null; }
+  signal.addEventListener("abort", stop, { once: true });
+  return () => signal.removeEventListener("abort", stop);
+}
+
 function cancelledCallRunResult(runContext) {
   return cancelledRunResult(runContext, { id: runContext.provider, label: runContext.provider }, "Call turn superseded or ended before execution");
 }
@@ -2669,7 +2736,7 @@ function cancelQueuedCallOnAbort(lane, item) {
 function drainQueuedMessages(_state) {
   for (const { state, lane } of waitingLanes()) {
     if (laneBusy(lane) || !lane.messageQueue.length) continue;
-    if (slotBlocker(state)) { lane.waitingForSlot = true; continue; }
+    if (!isCallLaneKey(lane.key) && slotBlocker(state)) { lane.waitingForSlot = true; continue; }
     const batch = takeQueueBatch(lane);
     const item = batch.length > 1 ? mergeQueueBatch(lane, batch) : batch[0];
     item.disposeCallListener?.();
@@ -3302,6 +3369,8 @@ function runAgentSilent(prompt, cwd, label, opts = {}) {
 }
 
 module.exports = {
+  stopCallRunWhenDropped,
+  persistForegroundTranscript,
   queuedNotice,
   handleQueueRemove,
   takeQueueBatch,

package/core/state.js

@@ -20,6 +20,7 @@ const {
   channelKey,
   identities,
   parseConversationKey,
+  isCallLaneKey,
 } = require("./identity");
 const { currentChannelId, currentCanonicalUserId, currentConversationKey, currentRoomKey } = require("./context");
 const { atomicWriteFileSync, readJsonWithFallback } = require("./fsutil");
@@ -1005,7 +1006,10 @@ function slotBlocker(state) {
 function admitLane(state = currentState(), laneKey = null) {
   const lane = laneFor(state, laneKey);
   if (laneBusy(lane)) return { ok: false, reason: "busy", lane };
-  const blocker = slotBlocker(state);
+  // A live call is real time: its turns never wait for a free slot (one call
+  // at a time, so at most one run over the caps).
+  const realtime = isCallLaneKey(lane.key);
+  const blocker = realtime ? null : slotBlocker(state);
   if (lane.messageQueue.length) return { ok: false, reason: "waiting", lane, running: blocker?.running || 0 };
   if (blocker) {
     lane.waitingForSlot = true;
@@ -1013,7 +1017,7 @@ function admitLane(state = currentState(), laneKey = null) {
   }
   // A freed slot goes to the lanes already waiting for one, oldest first: a
   // newcomer queues behind them (the runner then admits in order).
-  if (waitingLanes().some((waiting) => waiting.lane !== lane && !slotBlocker(waiting.state))) {
+  if (!realtime && waitingLanes().some((waiting) => waiting.lane !== lane && !slotBlocker(waiting.state))) {
     lane.waitingForSlot = true;
     return { ok: false, reason: "cap", lane, running: runningLanes(state).length, scope: "queue" };
   }

package/core/switchboard/brain-link.js

@@ -0,0 +1,161 @@
+// The brain's end of the switchboard link (only when OC_SWITCHBOARD started
+// this process as the switchboard's child). The call room lives in the
+// switchboard; a call job arrives here and becomes an ordinary call turn: a
+// per-job adapter made from the real Kazee adapter, as the call manager
+// always made it, whose speech and answer go back over the link.
+
+const { Link } = require("./ipc");
+const { isSwitchboardChild } = require("./handoff");
+
+let link = null;
+let goneHandled = false;
+// The channel also closes as this process exits on its own; not news then.
+let exiting = false;
+process.once("exit", () => { exiting = true; });
+let options = {};
+const jobs = new Map();
+
+function findAdapter(adapterId) {
+  if (options.findAdapter) return options.findAdapter(adapterId);
+  return require("../adapter-registry").findAdapter(adapterId);
+}
+
+// channel/findAdapter/onGone are test seams; the brain uses its own process.
+function connect({ channel = null, findAdapter: find = null, onGone = null } = {}) {
+  if (link) return link;
+  if (!channel && !isSwitchboardChild()) return null;
+  options = { findAdapter: find, onGone };
+  link = new Link(channel || process, { label: "switchboard" });
+  link.on("call.job", (payload) => {
+    try { startJob(payload); } catch (error) { console.error(`Switchboard call job failed to start: ${error.message}`); }
+  });
+  link.on("call.job.mirror", ({ id, mirror } = {}) => {
+    const job = jobs.get(id);
+    if (job && mirror) job.mirror = mirror;
+  });
+  link.on("call.job.abort", ({ id, reason } = {}) => {
+    const job = jobs.get(id);
+    if (job && !job.controller.signal.aborted) job.controller.abort(reason || "aborted");
+  });
+  link.on("call.job.forget", ({ id } = {}) => { jobs.delete(id); });
+  link.handle("call.carryOn", (payload) => carryOn(payload));
+  link.handle("call.greetingContext", (payload) => greetingContext(payload));
+  // The switchboard is gone (it crashed or was killed): this brain must go
+  // too, so the switchboard launchd or the pod starts next gets a free lock.
+  link.on("close", () => {
+    if (goneHandled || exiting) return;
+    goneHandled = true;
+    if (options.onGone) { options.onGone(); return; }
+    console.error("Switchboard link closed: shutting the brain down");
+    try { process.kill(process.pid, "SIGTERM"); } catch (_) {}
+  });
+  return link;
+}
+
+function hello() {
+  const l = connect();
+  if (!l) return false;
+  let version = null;
+  try { version = require("../../package.json").version; } catch (_) {}
+  return l.notify("brain.hello", { pid: process.pid, version });
+}
+
+// Said before a planned exit (restart, upgrade, shutdown): the call hears
+// "I'm restarting" instead of an unexplained gap.
+function notifyExiting(reason) {
+  exiting = true;
+  const l = link || connect();
+  return l ? l.notify("brain.exiting", { reason: String(reason || "restart") }) : false;
+}
+
+function configChanged(what) {
+  const l = link || connect();
+  return l ? l.notify("config.changed", { what }) : false;
+}
+
+function call(id, name, args) {
+  const l = connect();
+  if (!l) return Promise.reject(new Error("switchboard not connected"));
+  return l.request("call.job.fn", { id, name, args }, { timeoutMs: 0 });
+}
+
+function startJob({ id, adapterId, envelope, fields = {}, mirror = {}, resent = false } = {}) {
+  const base = findAdapter(adapterId);
+  if (!base || typeof base._emit !== "function") throw new Error(`no adapter ${adapterId}`);
+  const controller = new AbortController();
+  const job = { id, controller, mirror };
+  jobs.set(id, job);
+  const callAdapter = Object.create(base);
+  Object.assign(callAdapter, fields);
+  callAdapter.callTurn = { signal: controller.signal };
+  callAdapter.liveCallHistory = () => (job.mirror.history || []).map((entry) => ({ ...entry }));
+  callAdapter.liveCallCamera = () => {
+    const camera = job.mirror.camera;
+    if (!camera?.path) return null;
+    return { path: camera.path, ageMs: Math.max(0, Date.now() - (Number(camera.at) || Date.now())), receiving: camera.receiving !== false };
+  };
+  callAdapter.isCallTurnActive = () => !controller.signal.aborted && !!job.mirror.active;
+  callAdapter.cancelCallSpeech = () => { call(id, "cancelCallSpeech", []).catch(() => {}); };
+  callAdapter.onCallStage = (stage) => { call(id, "onCallStage", [stage]).catch(() => {}); };
+  callAdapter.onCallActivity = (event) => {
+    call(id, "onCallActivity", [{ type: event?.type, name: event?.name, detail: event?.detail }]).catch(() => {});
+  };
+  callAdapter.speakSentence = async (text) => {
+    try { return !!(await call(id, "speakSentence", [String(text ?? "")])); } catch (_) { return false; }
+  };
+  callAdapter.send = async (channelId, text) => {
+    try { return (await call(id, "send", [String(channelId), String(text ?? "")])) !== false; } catch (_) { return false; }
+  };
+  callAdapter.earlyCallAnswer = async (text) => {
+    try { return (await call(id, "earlyCallAnswer", [String(text ?? "")])) !== false; } catch (_) { return false; }
+  };
+  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;
+  };
+  if (resent) console.log(`Switchboard call job ${id} asked again after a brain restart`);
+  base._emit("message", { ...envelope, adapter: callAdapter });
+  return callAdapter;
+}
+
+function carryOn({ adapterId, chatId, userId, prompt, threadId = null } = {}) {
+  const adapter = findAdapter(adapterId) || { id: adapterId, type: "kazee" };
+  const job = require("../../channels/kazee/call/manager").carryOnInChat({ adapter, chatId, userId, prompt, threadId });
+  return { id: job?.id || null };
+}
+
+function greetingContext({ adapterId, chatId, userId, threadId = null } = {}) {
+  const adapter = findAdapter(adapterId) || { id: adapterId, type: "kazee" };
+  return require("../../channels/kazee/call/manager").greetingContext({ adapter, chatId, userId, ...(threadId ? { threadId } : {}) });
+}
+
+// The brain's stand-in for a Kazee adapter's call manager: calls are the
+// switchboard's, so the brain's socket ignores call events, stopping the
+// brain never ends a call, and `open-claudia call` is passed across.
+function callManagerProxy(adapter) {
+  return {
+    session: null,
+    switchboard: true,
+    wire() {},
+    async stop() {},
+    async outgoing(args = {}) {
+      const l = connect();
+      if (!l) throw new Error("switchboard not connected");
+      return l.request("call.outgoing", { adapterId: adapter.id, args }, { timeoutMs: 90000 });
+    },
+  };
+}
+
+function _resetForTests() {
+  goneHandled = true;
+  link?.close();
+  link = null;
+  options = {};
+  goneHandled = false;
+  exiting = false;
+  jobs.clear();
+}
+
+module.exports = { connect, hello, notifyExiting, configChanged, startJob, callManagerProxy, carryOn, greetingContext, jobs, _resetForTests };