@stage-labs/metro 0.1.0-beta.306 → 0.1.0-beta.308

package/runtime/node_modules/@metro-labs/daemon/src/voice/approvals.ts

@@ -1,38 +0,0 @@
-import { approvalId } from '@metro-labs/core/ids';
-import { errMsg, log } from '@metro-labs/core/log';
-import { forgetPromptsOf, holdPrompt, type Behavior } from '../approvals/pending.js';
-import { promptBody } from '../mcp/permission-prompt.js';
-import type { ToolAsk } from './brain.js';
-
-export class CallApprovals {
-  private closed = false;
-
-  constructor(
-    private readonly line: string,
-    private readonly post: (text: string) => Promise<void>,
-  ) {}
-
-  ask(ask: ToolAsk, answer: (behavior: Behavior) => void): string | null {
-    if (this.closed) return null;
-    const id = approvalId();
-    const preview = JSON.stringify(ask.input);
-    holdPrompt(
-      { requestId: id, tool: ask.tool, description: ask.description, preview, line: this.line, at: Date.now() },
-      this,
-      (behavior) => {
-        answer(behavior);
-        return Promise.resolve();
-      },
-      this.post,
-    );
-    this.post(promptBody({ request_id: id, tool_name: ask.tool, description: ask.description, input_preview: preview })).catch((err: unknown) => {
-      log.warn({ err: errMsg(err) }, 'voice: could not ask for an approval in the chat of the call');
-    });
-    return id;
-  }
-
-  close(): void {
-    this.closed = true;
-    forgetPromptsOf(this);
-  }
-}

package/runtime/node_modules/@metro-labs/daemon/src/voice/brain.ts

@@ -1,146 +0,0 @@
-import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
-import { errMsg, log } from '@metro-labs/core/log';
-import { isRecord } from '@metro-labs/core/is-record';
-import { drainLines } from '@metro-labs/core/trains/protocol';
-import { asAgent } from '../agent-user/user.js';
-import { metroCli } from '../claude/session.js';
-
-const CLOSE_GRACE_MS = 10_000;
-const DENIED = 'The owner did not approve this.';
-
-export interface ToolAsk {
-  requestId: string;
-  tool: string;
-  input: Record<string, unknown>;
-  description: string;
-  fromWorker: boolean;
-}
-
-export interface Thinking {
-  turnStarted(): void;
-  text(delta: string): void;
-  tool(name: string): void;
-  turnEnded(): void;
-  asked(ask: ToolAsk): void;
-  exited(reason: string): void;
-}
-
-const record = (value: unknown): Record<string, unknown> => (isRecord(value) ? value : {});
-const str = (value: unknown): string => (typeof value === 'string' ? value : '');
-
-export function toolAsk(msg: Record<string, unknown>): ToolAsk | null {
-  const request = record(msg.request);
-  const requestId = str(msg.request_id);
-  if (request.subtype !== 'can_use_tool' || requestId === '' || str(request.tool_name) === '') return null;
-  return {
-    requestId,
-    tool: str(request.tool_name),
-    input: record(request.input),
-    description: str(request.description) || str(request.decision_reason),
-    fromWorker: str(request.agent_id) !== '',
-  };
-}
-
-function streamEvent(msg: Record<string, unknown>, mind: Thinking): void {
-  if (msg.parent_tool_use_id !== null && msg.parent_tool_use_id !== undefined) return;
-  const event = record(msg.event);
-  const delta = record(event.delta);
-  if (event.type === 'content_block_delta' && delta.type === 'text_delta' && typeof delta.text === 'string') mind.text(delta.text);
-  const block = record(event.content_block);
-  if (event.type === 'content_block_start' && block.type === 'tool_use') mind.tool(typeof block.name === 'string' ? block.name : 'tool');
-}
-
-function startBrain(model: string): ChildProcessWithoutNullStreams {
-  const [command = 'metro', ...args] = metroCli(['voice', '--model', model]);
-  const [file, argv] = asAgent(command, args);
-  return spawn(file, argv, { stdio: ['pipe', 'pipe', 'pipe'], cwd: '/' });
-}
-
-export class Brain {
-  private readonly child: ChildProcessWithoutNullStreams;
-  private out = '';
-  private gone = false;
-  private closing = false;
-  private killTimer: ReturnType<typeof setTimeout> | undefined;
-
-  constructor(model: string, private readonly mind: Thinking, launch = startBrain) {
-    this.child = launch(model);
-    this.child.stdout.setEncoding('utf8');
-    this.child.stdout.on('data', (chunk: string) => {
-      this.out = drainLines('voice-brain', this.out + chunk, (line) => {
-        this.read(line);
-      });
-    });
-    this.child.stderr.setEncoding('utf8');
-    this.child.stderr.on('data', (chunk: string) => {
-      log.debug({ text: chunk.slice(0, 500) }, 'voice: brain stderr');
-    });
-    this.child.stdin.on('error', (err) => {
-      log.debug({ err: errMsg(err) }, 'voice: brain stdin closed');
-    });
-    this.child.on('error', (err) => {
-      this.exit(`could not start: ${errMsg(err)}`);
-    });
-    this.child.on('exit', (code, signal) => {
-      this.exit(`exited (${String(code ?? signal)})`);
-    });
-  }
-
-  tell(text: string, now = false): void {
-    const message = { type: 'user', message: { role: 'user', content: text }, parent_tool_use_id: null, session_id: '' };
-    this.write(now ? { ...message, priority: 'now' } : message);
-  }
-
-  answer(ask: ToolAsk, behavior: 'allow' | 'deny'): void {
-    const response = behavior === 'allow' ? { behavior, updatedInput: ask.input } : { behavior, message: DENIED };
-    this.write({ type: 'control_response', response: { subtype: 'success', request_id: ask.requestId, response } });
-  }
-
-  close(): void {
-    if (this.gone || this.closing) return;
-    this.closing = true;
-    this.child.stdin.end();
-    this.child.kill('SIGTERM');
-    this.killTimer = setTimeout(() => {
-      if (!this.gone) this.child.kill('SIGKILL');
-    }, CLOSE_GRACE_MS);
-    this.killTimer.unref();
-  }
-
-  private write(message: Record<string, unknown>): void {
-    if (!this.gone && !this.closing && this.child.stdin.writable) this.child.stdin.write(`${JSON.stringify(message)}\n`);
-  }
-
-  private read(line: string): void {
-    if (this.closing || this.gone) return;
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      return;
-    }
-    const msg = record(parsed);
-    if (msg.type === 'system' && msg.subtype === 'init') this.mind.turnStarted();
-    else if (msg.type === 'stream_event') streamEvent(msg, this.mind);
-    else if (msg.type === 'result') this.mind.turnEnded();
-    else if (msg.type === 'control_request') this.control(msg);
-  }
-
-  private control(msg: Record<string, unknown>): void {
-    const ask = toolAsk(msg);
-    if (ask !== null) {
-      this.mind.asked(ask);
-      return;
-    }
-    const subtype = str(record(msg.request).subtype);
-    log.warn({ subtype }, 'voice: the agent session asked for something the call does not handle');
-    this.write({ type: 'control_response', response: { subtype: 'error', request_id: str(msg.request_id), error: `not supported on a voice call: ${subtype}` } });
-  }
-
-  private exit(reason: string): void {
-    if (this.gone) return;
-    this.gone = true;
-    clearTimeout(this.killTimer);
-    if (!this.closing) this.mind.exited(reason);
-  }
-}

package/runtime/node_modules/@metro-labs/daemon/src/voice/speakable.ts

@@ -1,54 +0,0 @@
-const FIRST_CLAUSE_MIN = 24;
-const LONGEST = 220;
-const SENTENCE_END = /[.!?…]+["')\]]*\s+|\n+/g;
-const CLAUSE_END = /[,;:]\s+/g;
-
-function speakable(text: string): string {
-  return text
-    .replace(/https?:\/\/\S+/g, 'the link')
-    .replace(/`{1,3}[^`]*`{1,3}/g, (code) => code.replace(/`/g, ''))
-    .replace(/^\s*(?:#+|[-*•]|\d+\.)\s+/gm, '')
-    .replace(/[*_~#|<>[\]{}]/g, '')
-    .replace(/\s+/g, ' ')
-    .trim();
-}
-
-function lastEnd(text: string, pattern: RegExp): number {
-  let end = -1;
-  for (const match of text.matchAll(pattern)) end = match.index + match[0].length;
-  return end;
-}
-
-function cutAt(text: string, first: boolean): number {
-  const sentence = lastEnd(text, SENTENCE_END);
-  if (sentence > 0) return sentence;
-  if (first && text.length >= FIRST_CLAUSE_MIN) {
-    const clause = lastEnd(text, CLAUSE_END);
-    if (clause > 0) return clause;
-  }
-  if (text.length < LONGEST) return -1;
-  const space = text.lastIndexOf(' ');
-  return space > 0 ? space + 1 : text.length;
-}
-
-export class Chunker {
-  private buffer = '';
-  private first = true;
-
-  add(delta: string): string[] {
-    this.buffer += delta;
-    const at = cutAt(this.buffer, this.first);
-    if (at < 0) return [];
-    const ready = speakable(this.buffer.slice(0, at));
-    this.buffer = this.buffer.slice(at);
-    if (ready === '') return [];
-    this.first = false;
-    return [ready];
-  }
-
-  flush(): string[] {
-    const rest = speakable(this.buffer);
-    this.buffer = '';
-    return rest === '' ? [] : [rest];
-  }
-}

package/runtime/node_modules/@metro-labs/daemon/src/voice/talk.ts

@@ -1,264 +0,0 @@
-import { log } from '@metro-labs/core/log';
-import { downsample3, OpusIn, Player, type Playback } from './audio.js';
-import type { CallApprovals } from './approvals.js';
-import { Brain, type Thinking, type ToolAsk } from './brain.js';
-import { Scribe, VAD_SILENCE_SECS } from './scribe.js';
-import { Utterance } from './speech.js';
-import { Chunker } from './speakable.js';
-import { brainModel, languageOf, voiceIdOf, type VoiceConfig } from './store.js';
-
-const BARGE_MIN_WORDS = 2;
-
-interface Reply {
-  utterance: Utterance;
-  said: string;
-  heard: number;
-  chunker: Chunker;
-  askedAt: number | null;
-  saidAt: number | null;
-  firstText: number | null;
-  firstAudio: number | null;
-  firstPlayed: number | null;
-}
-
-const toolName = (tool: string): string => tool.split('__').pop() ?? tool;
-
-const approvalNote = (tool: string, id: string): string =>
-  `[The owner was asked in the chat of this call to approve ${toolName(tool)}; they answer "yes ${id}" or "no ${id}" there. Unless you already said so, tell the caller in one short sentence that it waits for their answer in the chat.]`;
-
-const wordsIn = (text: string): number => text.split(/\s+/).filter((word) => /\p{L}/u.test(word)).length;
-
-const since = (start: number | null, at: number | null): number | null =>
-  start === null || at === null ? null : Math.round(at - start);
-
-function heardNote(reply: Reply | null): string | null {
-  if (reply === null || reply.said.trim() === '' || reply.heard >= reply.said.trim().length - 2) return null;
-  const part = reply.said.slice(0, reply.heard).trim();
-  return part === ''
-    ? '[The caller interrupted you before hearing your reply.]'
-    : `[The caller interrupted you. They heard only: "${part}". The rest of your reply was not heard.]`;
-}
-
-export class Talk implements Thinking {
-  private readonly brain: Brain;
-  private readonly scribe: Scribe;
-  private readonly opus = new OpusIn();
-  private readonly player: Player;
-  private spare: Utterance | null = null;
-  private reply: Reply | null = null;
-  private cut: string | null = null;
-  private muted = false;
-  private askedAt: number | null = null;
-  private saidAt: number | null = null;
-  private lastHeardAt: number | null = null;
-  private readonly delays: number[] = [];
-  private live = false;
-  private finished = false;
-  private spoke = false;
-
-  constructor(
-    private readonly cfg: VoiceConfig,
-    out: Playback['send'],
-    private readonly ended: (reason: string) => void,
-    private readonly approvals: CallApprovals,
-  ) {
-    const playback: Playback = {
-      send: out,
-      played: (chars) => {
-        this.played(chars);
-      },
-    };
-    this.player = new Player(playback);
-    this.player.whenFirstPlayed(() => {
-      this.firstPlayed();
-    });
-    this.player.whenFailed((reason) => {
-      if (!this.finished) this.ended(`audio playback failed: ${reason}`);
-    });
-    this.brain = new Brain(brainModel(cfg), this);
-    this.scribe = new Scribe(cfg.apiKey, languageOf(cfg), {
-      partial: (text) => {
-        this.partial(text);
-      },
-      committed: (text) => {
-        this.committed(text);
-      },
-      failed: (reason) => {
-        this.ended(reason);
-      },
-    });
-    this.spare = this.utterance();
-  }
-
-  prime(context: string): void {
-    if (!this.finished) this.brain.tell(context);
-  }
-
-  connect(): void {
-    if (this.finished || this.live) return;
-    this.live = true;
-    this.spare ??= this.utterance();
-    this.player.start();
-  }
-
-  hear(packet: Buffer): void {
-    if (this.finished) return;
-    const pcm = this.opus.decode(packet);
-    if (pcm !== null) this.scribe.send(downsample3(pcm));
-  }
-
-  finish(): void {
-    if (this.finished) return;
-    this.finished = true;
-    this.live = false;
-    this.approvals.close();
-    this.player.stop();
-    this.scribe.close();
-    this.reply?.utterance.abort();
-    this.spare?.abort();
-    this.opus.close();
-    this.brain.close();
-    this.logReplyTime();
-  }
-
-  turnStarted(): void {
-    if (this.finished) return;
-    this.muted = false;
-    this.reply = {
-      utterance: this.takeUtterance(),
-      said: '',
-      heard: 0,
-      chunker: new Chunker(),
-      askedAt: this.askedAt,
-      saidAt: this.saidAt,
-      firstText: null,
-      firstAudio: null,
-      firstPlayed: null,
-    };
-    this.askedAt = null;
-    this.saidAt = null;
-  }
-
-  text(delta: string): void {
-    const reply = this.reply;
-    if (this.finished || this.muted || reply === null) return;
-    reply.firstText ??= performance.now();
-    this.speak(reply, reply.chunker.add(delta));
-  }
-
-  tool(name: string): void {
-    if (this.finished) return;
-    log.info({ tool: name }, 'voice: the agent uses a tool during the call');
-    if (this.reply !== null && !this.muted) this.speak(this.reply, this.reply.chunker.flush());
-  }
-
-  turnEnded(): void {
-    const reply = this.reply;
-    if (this.finished || reply === null || this.muted) return;
-    this.speak(reply, reply.chunker.flush());
-    reply.utterance.end();
-    log.info(
-      { firstText: since(reply.askedAt, reply.firstText), firstAudio: since(reply.askedAt, reply.firstAudio), vadSilenceMs: VAD_SILENCE_SECS * 1000 },
-      'voice: reply timing in ms from the caller’s words being committed',
-    );
-  }
-
-  asked(ask: ToolAsk): void {
-    const id = this.finished ? null : this.approvals.ask(ask, (behavior) => {
-      this.brain.answer(ask, behavior);
-    });
-    if (id === null) {
-      this.brain.answer(ask, 'deny');
-      return;
-    }
-    log.info({ tool: ask.tool, worker: ask.fromWorker }, 'voice: a tool waits for the owner’s approval in the chat of the call');
-    this.brain.tell(approvalNote(ask.tool, id));
-  }
-
-  exited(reason: string): void {
-    if (this.finished) return;
-    log.warn({ reason }, 'voice: the agent session for the call ended');
-    this.ended(`agent session ${reason}`);
-  }
-
-  private takeUtterance(): Utterance {
-    const ready = this.spare?.usable === true ? this.spare : this.utterance();
-    this.spare = this.live ? this.utterance() : null;
-    if (ready === this.spare) this.spare = null;
-    const reply = (): Reply | null => this.reply;
-    ready.attach({
-      audio: (pcm, chars) => {
-        const current = reply();
-        if (this.finished || this.muted || current?.utterance !== ready) return;
-        this.spoke = true;
-        current.firstAudio ??= performance.now();
-        this.player.push(pcm, chars);
-      },
-      done: () => {
-        if (!this.finished && !this.muted && this.reply?.utterance === ready) this.player.finish();
-      },
-    });
-    return ready;
-  }
-
-  private utterance(): Utterance {
-    return new Utterance(this.cfg.apiKey, voiceIdOf(this.cfg), (reason) => {
-      log.warn({ reason }, 'voice: text to speech gave no audio');
-      if (!this.spoke && !this.finished) this.ended(`ElevenLabs could not speak (${reason})`);
-    });
-  }
-
-  private speak(reply: Reply, parts: string[]): void {
-    for (const part of parts) {
-      reply.said += `${part} `;
-      reply.utterance.say(part);
-    }
-  }
-
-  private played(chars: number): void {
-    if (this.reply !== null) this.reply.heard += chars;
-  }
-
-  private logReplyTime(): void {
-    if (this.delays.length === 0) return;
-    const sorted = [...this.delays].sort((a, b) => a - b);
-    log.info({ middleMs: Math.round(sorted[Math.floor(sorted.length / 2)] ?? 0), replies: sorted.length }, 'voice: reply time of the call, from the caller’s last word heard to the first reply audio sent');
-  }
-
-  private firstPlayed(): void {
-    const reply = this.reply;
-    if (reply?.firstPlayed !== null || reply.saidAt === null) return;
-    reply.firstPlayed = performance.now();
-    this.delays.push(reply.firstPlayed - reply.saidAt);
-    log.info({ fromLastWord: since(reply.saidAt, reply.firstPlayed), fromCommit: since(reply.askedAt, reply.firstPlayed) }, 'voice: first reply audio sent to the caller, in ms');
-  }
-
-  private interrupts(text: string): boolean {
-    return !this.muted && this.player.busy && wordsIn(text) >= BARGE_MIN_WORDS;
-  }
-
-  private cutOff(): void {
-    this.cut = heardNote(this.reply);
-    this.reply?.utterance.abort();
-    this.player.clear();
-    this.muted = true;
-  }
-
-  private partial(text: string): void {
-    if (this.finished) return;
-    if (text !== '') this.lastHeardAt = performance.now();
-    if (this.interrupts(text)) this.cutOff();
-  }
-
-  private committed(text: string): void {
-    if (this.finished) return;
-    if (this.interrupts(text)) this.cutOff();
-    const note = this.cut;
-    const now = this.muted;
-    this.cut = null;
-    this.askedAt = performance.now();
-    this.saidAt = this.lastHeardAt ?? this.askedAt;
-    this.lastHeardAt = null;
-    this.brain.tell(note === null ? text : `${note}\n${text}`, now);
-  }
-}