@inetafrica/open-claudia 3.5.27 → 3.5.28

package/channels/kazee/call/quick-voice.js

@@ -1,295 +0,0 @@
-"use strict";
-
-// The quick voice: a small, kept-warm model that says a short, fitting line
-// the moment the caller finishes ("Sure, let me check the call logs."), and a
-// brief "still on it" line while the full agent works. It never answers: the
-// full agent's call turn still runs for every utterance and speaks the real
-// reply. One process per call, spawned through the provider's own utility
-// invocation (binary, env and credentials come from the provider, never from
-// here). Ported from the 5 Oct front-voice test build, reduced to this job.
-
-const { spawn } = require("child_process");
-const { StringDecoder } = require("string_decoder");
-const { killProcessTree } = require("../../../core/process-tree");
-const { redactSensitive } = require("../../../core/redact");
-
-const KILL_GRACE_MS = 2000;
-const MAX_BUFFER_BYTES = 1024 * 1024;
-const MAX_LINE_CHARS = 120;
-const EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
-
-// The bot's .env is parsed into the config object, not process.env: read the
-// config first, the environment second.
-function setting(name) {
-  let value = process.env[name];
-  try { value = require("../../../core/config").config?.[name] ?? value; } catch (_) {}
-  return String(value ?? "").trim();
-}
-
-// Measured 11 Oct, warm process, thinking off, 23 call lines with traps
-// ("Did you hear me?", "Are you sure?"): Haiku 4.5 finished its line in
-// 0.8-1.1 s (Sonnet 5 at low effort 1.7-1.9 s); both kept every rule once the
-// prompt named the traps (a looser prompt let Haiku answer "you said it once").
-function quickVoiceSettings() {
-  const effort = setting("KAZEE_CALL_QUICK_EFFORT").toLowerCase() || "low";
-  return {
-    enabled: /^(?:on|1|true|yes)$/i.test(setting("KAZEE_CALL_QUICK_VOICE")),
-    model: setting("KAZEE_CALL_QUICK_MODEL") || "claude-haiku-4-5",
-    effort: EFFORTS.has(effort) ? effort : "low",
-    thinking: /^(?:on|1|true|yes)$/i.test(setting("KAZEE_CALL_QUICK_THINKING")),
-  };
-}
-
-function ownerDisplayName() {
-  try {
-    const name = String(require("../../../core/people").owners()?.[0]?.name || "").trim();
-    return name && name.toLowerCase() !== "owner" ? name : "";
-  } catch (_) {
-    return "";
-  }
-}
-
-// Caller words and spoken history only: no file paths, links, ids or secrets
-// reach the quick voice.
-function scrubLine(text) {
-  return redactSensitive(String(text || ""))
-    .replace(/https?:\/\/\S+/gi, "a link")
-    .replace(/(?:~|\.{1,2})?\/[\w.@%+-]+(?:\/[\w.@%+-]*)+/g, "a file")
-    .replace(/\b(?=[A-Za-z0-9_-]*\d)[A-Za-z0-9_-]{16,}\b/g, "an id")
-    .replace(/\[REDACTED[^\]]*\]/g, "something private")
-    .replace(/[`*_#>|[\]]/g, " ")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-
-function buildQuickPrompt({ ownerName = "" } = {}) {
-  const owner = scrubLine(ownerName).slice(0, 60) || "the caller";
-  return [
-    `You are the quick voice of Claudia, ${owner}'s assistant, on a live phone call with ${owner}.`,
-    "Claudia herself (the full assistant, with tools) answers every request a few seconds after you. Your only job is to fill the first moment, so the caller knows they were heard.",
-    "",
-    "Reply with ONE short spoken line, 2 to 8 words, that fits what was just said:",
-    "- a greeting or a check like \"Hello?\" or \"Are you there?\": a warm, brief reply, like \"Yep, I'm here.\"",
-    "- a question: \"Good question, one sec.\", or a line naming the topic, like \"Let me look at the budget.\"",
-    "- a request: \"Sure, let me check the call logs.\", naming the thing in two or three words.",
-    "- thanks or small talk: a short natural reply.",
-    "- a correction or \"that's wrong\": \"Okay, let me look again.\"",
-    "Never answer, even when you think you know: \"Did you hear me?\" gets \"Let me check.\", never \"Yes, once.\"; \"Are you sure?\" gets \"Let me double-check.\".",
-    "Never give facts, numbers, yes or no, opinions or apologies; never say anything was done, found, sent or changed. For sending, changing, booking or deleting anything, say \"Sure, one sec.\" and never that it is being done.",
-    "No lists, emoji, symbols or markdown.",
-    "",
-    "A message that starts with [Still working] means Claudia is still on it: say a short, varied line of 3 to 7 words, like \"Still on it, nearly there.\" Never repeat an earlier line word for word.",
-  ].join("\n");
-}
-
-// What the quick voice should say for one utterance, or a filler while the
-// full agent is still working.
-function utteranceMessage(text) {
-  return scrubLine(text).slice(0, 600);
-}
-
-function fillerMessage(text, seconds) {
-  return `[Still working] on "${scrubLine(text).slice(0, 200)}", ${Math.round(seconds)} seconds in.`;
-}
-
-// A spoken line from model text: first line only, no control or markup,
-// bounded. Empty means "say nothing".
-function spokenLine(text) {
-  const line = String(text || "").split("\n").map((part) => part.trim()).find(Boolean) || "";
-  const clean = scrubLine(line).replace(/^["']|["']$/g, "").trim();
-  if (!clean || !/[A-Za-z]/.test(clean)) return "";
-  return clean.length > MAX_LINE_CHARS ? `${clean.slice(0, MAX_LINE_CHARS - 1)}…` : clean;
-}
-
-class QuickVoiceProcess {
-  constructor({ provider, settings = quickVoiceSettings(), systemPrompt, cwd = process.cwd(), spawnImpl = spawn, maxRestarts = 1, log = () => {} } = {}) {
-    this.provider = provider;
-    this.settings = settings;
-    this.systemPrompt = systemPrompt;
-    this.cwd = cwd;
-    this.spawnImpl = spawnImpl;
-    this.maxRestarts = maxRestarts;
-    this.log = log;
-    this.proc = null;
-    this.restarts = 0;
-    this.stopped = false;
-    this.queue = []; // generations awaiting their result, oldest first
-    this._seq = 0;
-    this._stopPromise = null;
-  }
-
-  static supported(provider) {
-    return provider?.id === "claude" && provider.capabilities?.persistentUtilityStream?.support === "native" &&
-      typeof provider.buildUtilityInvocation === "function";
-  }
-
-  invocation() {
-    const { model, effort, thinking } = this.settings;
-    const invocation = this.provider.buildUtilityInvocation({
-      purpose: "call-quick-voice",
-      tier: "low",
-      model,
-      effort,
-      coreInstructions: this.systemPrompt,
-      dynamicContext: "",
-      userPrompt: "",
-      readOnly: true,
-      fresh: true,
-    });
-    const args = [...invocation.args];
-    // The slim prompt replaces the CLI's default system prompt (no tool docs
-    // to read), which is most of what makes a warm reply start in about a second.
-    const appendAt = args.indexOf("--append-system-prompt");
-    if (appendAt >= 0) args[appendAt] = "--system-prompt";
-    const printAt = args.indexOf("-p");
-    args.splice(printAt >= 0 ? printAt + 1 : 0, 0,
-      "--input-format", "stream-json", "--include-partial-messages",
-      "--tools", "", "--strict-mcp-config", "--setting-sources", "");
-    if (!args.includes("--no-session-persistence")) args.push("--no-session-persistence");
-    const env = { ...invocation.env, OC_PROVIDER: this.provider.id, OC_UTILITY_PURPOSE: "call-quick-voice" };
-    // Thinking off: Haiku 4.5 went from 2-3 s to 0.7 s to its first word.
-    if (!thinking) env.MAX_THINKING_TOKENS = "0";
-    return { binary: invocation.binary, args, env };
-  }
-
-  start() {
-    if (this.stopped || this.proc) return this.proc;
-    const { binary, args, env } = this.invocation();
-    const proc = this.spawnImpl(binary, args, {
-      cwd: this.cwd, env, stdio: ["pipe", "pipe", "pipe"], detached: process.platform !== "win32", shell: false,
-    });
-    this.proc = proc;
-    const decoder = new StringDecoder("utf8");
-    let buffer = "";
-    proc.stdout.on("data", (data) => {
-      if (this.proc !== proc) return;
-      buffer += decoder.write(data);
-      if (buffer.length > MAX_BUFFER_BYTES) { buffer = ""; this._crashed(proc, "buffer"); return; }
-      let newline;
-      while ((newline = buffer.indexOf("\n")) >= 0) {
-        const line = buffer.slice(0, newline).trim();
-        buffer = buffer.slice(newline + 1);
-        if (!line) continue;
-        let event;
-        try { event = JSON.parse(line); } catch (_) { continue; }
-        this._onEvent(event);
-      }
-    });
-    proc.stderr.on("data", () => {});
-    proc.stdin.on("error", () => {});
-    proc.on("error", () => this._crashed(proc, "spawn-error"));
-    proc.on("close", () => this._crashed(proc, "exited"));
-    this.log(`started pid=${proc.pid ?? "?"} model=${this.settings.model} effort=${this.settings.effort} thinking=${this.settings.thinking ? "on" : "off"}`);
-    return proc;
-  }
-
-  ready() {
-    const proc = this.proc;
-    return !this.stopped && !!proc && proc.exitCode === null && proc.signalCode === null && !proc.stdin.destroyed;
-  }
-
-  // One user message; resolves with the reply text as soon as its text block
-  // closes (before the CLI's end-of-turn work), or "" when cancelled/failed.
-  say(content) {
-    if (!this.ready()) return { generation: null, text: Promise.resolve("") };
-    let resolve;
-    const text = new Promise((done) => { resolve = done; });
-    const generation = { id: ++this._seq, text: "", cancelled: false, settled: false, resolve };
-    this.queue.push(generation);
-    try {
-      this.proc.stdin.write(`${JSON.stringify({ type: "user", message: { role: "user", content: String(content) } })}\n`);
-    } catch (_) {
-      this.queue = this.queue.filter((item) => item !== generation);
-      resolve("");
-    }
-    return { generation, text };
-  }
-
-  // Stops the in-flight generation (Claude Code's stream-json control
-  // protocol); the CLI then closes that turn with an error result.
-  cancel(generation) {
-    if (!generation || generation.cancelled) return;
-    generation.cancelled = true;
-    generation.resolve("");
-    if (generation.settled || this.queue[0] !== generation || !this.ready()) return;
-    try {
-      this.proc.stdin.write(`${JSON.stringify({ type: "control_request", request_id: `quick-interrupt-${generation.id}`, request: { subtype: "interrupt" } })}\n`);
-    } catch (_) {}
-  }
-
-  _onEvent(event) {
-    const generation = this.queue[0];
-    if (!generation) return;
-    if (event.type === "stream_event") {
-      const inner = event.event || {};
-      if (inner.type === "content_block_delta" && inner.delta?.type === "text_delta" && typeof inner.delta.text === "string") {
-        generation.text += inner.delta.text;
-      } else if (inner.type === "content_block_stop" && generation.text.trim()) {
-        generation.resolve(generation.cancelled ? "" : generation.text);
-      }
-    } else if (event.type === "assistant" && !generation.text && Array.isArray(event.message?.content)) {
-      // A CLI without partial messages: the whole reply at once.
-      generation.text = event.message.content.filter((block) => block?.type === "text").map((block) => block.text || "").join("");
-    } else if (event.type === "result") {
-      this.queue.shift();
-      generation.settled = true;
-      generation.resolve(generation.cancelled || event.is_error ? "" : generation.text);
-    }
-  }
-
-  _crashed(proc, reason) {
-    if (this.proc !== proc) return;
-    this.proc = null;
-    for (const generation of this.queue.splice(0)) { generation.settled = true; generation.resolve(""); }
-    try { killProcessTree(proc.pid, "SIGKILL"); } catch (_) {}
-    if (this.stopped) return;
-    if (this.restarts >= this.maxRestarts) {
-      this.log(`gave up reason=${reason} restarts=${this.restarts}`);
-      return;
-    }
-    this.restarts += 1;
-    this.log(`restart reason=${reason} restarts=${this.restarts}`);
-    try { this.start(); } catch (error) { this.log(`restart failed: ${error.message}`); }
-  }
-
-  stop() {
-    if (this._stopPromise) return this._stopPromise;
-    this.stopped = true;
-    live.delete(this);
-    const proc = this.proc;
-    this.proc = null;
-    for (const generation of this.queue.splice(0)) { generation.settled = true; generation.cancelled = true; generation.resolve(""); }
-    if (!proc) return (this._stopPromise = Promise.resolve());
-    this._stopPromise = new Promise((resolve) => {
-      let killTimer = null;
-      const finish = () => { if (killTimer) clearTimeout(killTimer); resolve(); };
-      if (proc.exitCode !== null || proc.signalCode !== null) return finish();
-      proc.once("close", finish);
-      try { proc.stdin.end(); } catch (_) {}
-      try { killProcessTree(proc.pid, "SIGTERM"); } catch (_) { try { proc.kill("SIGTERM"); } catch (_) {} }
-      killTimer = setTimeout(() => {
-        try { killProcessTree(proc.pid, "SIGKILL"); } catch (_) { try { proc.kill("SIGKILL"); } catch (_) {} }
-      }, KILL_GRACE_MS);
-      killTimer.unref?.();
-    });
-    return this._stopPromise;
-  }
-}
-
-// A bot exit never leaves a quick-voice process behind.
-const live = new Set();
-function track(quick) {
-  live.add(quick);
-  return quick;
-}
-process.on("exit", () => {
-  for (const quick of live) {
-    const pid = quick.proc?.pid;
-    if (pid) { try { killProcessTree(pid, "SIGKILL"); } catch (_) {} }
-  }
-});
-
-module.exports = {
-  QuickVoiceProcess, quickVoiceSettings, buildQuickPrompt, utteranceMessage, fillerMessage, spokenLine,
-  scrubLine, ownerDisplayName, track,
-};