@stage-labs/metro 0.1.0-beta.26 → 0.1.0-beta.261

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

@@ -0,0 +1,116 @@
+import { join } from 'node:path';
+import { readJson, writeSecure } from '@metro-labs/core/secure-fs';
+import { isRecord } from '@metro-labs/core/is-record';
+import { ApiError } from '@metro-labs/http/api-error';
+import { agentsDir } from '../agents/files.js';
+import { readModelConfig, type ModelConfig } from '../gateway/model-config.js';
+
+const VOICE_PROVIDERS = ['elevenlabs'] as const;
+type VoiceProvider = (typeof VOICE_PROVIDERS)[number];
+
+export interface VoiceConfig {
+  provider: VoiceProvider;
+  apiKey: string;
+  voiceId: string;
+  model: string;
+  language: string;
+  enabled: boolean;
+}
+
+const DEFAULT_LANGUAGE = 'en';
+const AUTO_LANGUAGE = 'auto';
+const LANGUAGE_RE = /^(?:[a-z]{2,3}|auto)$/;
+
+const DEFAULT_VOICE_ID = 'EXAVITQu4vr4xnSDxMaL';
+const DEFAULT_VOICE_MODEL = 'anthropic:claude-sonnet-5-5';
+
+const VOICE_FILE = 'voice.json';
+const MAX_FIELD = 512;
+
+const text = (value: unknown): string => (typeof value === 'string' ? value.trim() : '');
+
+const isProvider = (value: unknown): value is VoiceProvider =>
+  typeof value === 'string' && (VOICE_PROVIDERS as readonly string[]).includes(value);
+
+export function parseVoice(raw: unknown): VoiceConfig {
+  const r = isRecord(raw) ? raw : {};
+  return {
+    provider: isProvider(r.provider) ? r.provider : 'elevenlabs',
+    apiKey: text(r.apiKey),
+    voiceId: text(r.voiceId),
+    model: text(r.model),
+    language: LANGUAGE_RE.test(text(r.language)) ? text(r.language) : '',
+    enabled: r.enabled !== false,
+  };
+}
+
+export const readVoice = (dir = agentsDir()): VoiceConfig =>
+  parseVoice(readJson<unknown>(join(dir, VOICE_FILE), null, { warn: 'voice: voice.json is not readable' }));
+
+export function writeVoice(cfg: VoiceConfig, dir = agentsDir()): void {
+  writeSecure(join(dir, VOICE_FILE), JSON.stringify(cfg, null, 2));
+}
+
+export const voiceIdOf = (cfg: VoiceConfig): string => (cfg.voiceId === '' ? DEFAULT_VOICE_ID : cfg.voiceId);
+const voiceModelOf = (cfg: VoiceConfig): string => (cfg.model === '' ? DEFAULT_VOICE_MODEL : cfg.model);
+export function brainModel(cfg: VoiceConfig, models: ModelConfig = readModelConfig()): string {
+  const model = voiceModelOf(cfg);
+  const anthropic = /^anthropic:(.+)$/.exec(model)?.[1];
+  if (anthropic === undefined) return model;
+  return models.connections.some((c) => c.provider === 'anthropic') ? model : anthropic;
+}
+
+export function languageOf(cfg: VoiceConfig): string | null {
+  const language = cfg.language === '' ? DEFAULT_LANGUAGE : cfg.language;
+  return language === AUTO_LANGUAGE ? null : language;
+}
+
+export const voiceReady = (cfg: VoiceConfig): boolean => cfg.enabled && cfg.apiKey !== '';
+
+export function publicVoice(cfg: VoiceConfig): Record<string, unknown> {
+  return {
+    provider: cfg.provider,
+    providers: VOICE_PROVIDERS,
+    hasKey: cfg.apiKey !== '',
+    voiceId: cfg.voiceId,
+    model: cfg.model,
+    language: cfg.language,
+    enabled: cfg.enabled,
+    defaults: { voiceId: DEFAULT_VOICE_ID, model: DEFAULT_VOICE_MODEL, language: DEFAULT_LANGUAGE },
+  };
+}
+
+function field(body: Record<string, unknown>, key: string, current: string): string {
+  const value = body[key];
+  if (value === undefined) return current;
+  if (typeof value !== 'string') throw new ApiError(`${key} must be a string`, 400);
+  if (value.length > MAX_FIELD) throw new ApiError(`${key} is too long`, 400);
+  return value.trim();
+}
+
+function keyOf(body: Record<string, unknown>, current: string): string {
+  if (body.apiKey === null) return '';
+  const next = field(body, 'apiKey', current);
+  return next === '' ? current : next;
+}
+
+function languageField(body: Record<string, unknown>, current: string): string {
+  const next = field(body, 'language', current).toLowerCase();
+  if (next !== '' && !LANGUAGE_RE.test(next)) throw new ApiError("language is a two or three letter ISO 639 code, or 'auto'", 400);
+  return next;
+}
+
+export function patchVoice(cfg: VoiceConfig, body: unknown): VoiceConfig {
+  if (!isRecord(body)) throw new ApiError('the body must be a JSON object', 400);
+  if (body.provider !== undefined && !isProvider(body.provider))
+    throw new ApiError(`provider must be one of ${VOICE_PROVIDERS.join(', ')}`, 400);
+  if (body.enabled !== undefined && typeof body.enabled !== 'boolean') throw new ApiError('enabled must be true or false', 400);
+  return {
+    provider: isProvider(body.provider) ? body.provider : cfg.provider,
+    apiKey: keyOf(body, cfg.apiKey),
+    voiceId: field(body, 'voiceId', cfg.voiceId),
+    model: field(body, 'model', cfg.model),
+    language: languageField(body, cfg.language),
+    enabled: typeof body.enabled === 'boolean' ? body.enabled : cfg.enabled,
+  };
+}

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

@@ -0,0 +1,256 @@
+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: (opus: Buffer, timestamp: number, marker: boolean) => void,
+    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.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 {
+    this.brain.tell(context);
+  }
+
+  connect(): void {
+    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 {
+    this.muted = false;
+    if (this.finished) return;
+    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.muted || reply === null) return;
+    reply.firstText ??= performance.now();
+    this.speak(reply, reply.chunker.add(delta));
+  }
+
+  tool(name: string): void {
+    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 (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 {
+    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 (current?.utterance !== ready) return;
+        this.spoke = true;
+        current.firstAudio ??= performance.now();
+        this.player.push(pcm, chars);
+      },
+      done: () => {
+        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 (text !== '') this.lastHeardAt = performance.now();
+    if (this.interrupts(text)) this.cutOff();
+  }
+
+  private committed(text: string): void {
+    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);
+  }
+}

package/runtime/node_modules/@metro-labs/discord-bot/package.json

@@ -13,13 +13,11 @@
     "test": "tsc --noEmit && bun test test/"
   },
   "dependencies": {
-    "@metro-labs/mcp": "workspace:*",
-    "@discordjs/voice": "^0.19.2",
-    "discord.js": "^14.26.4",
-    "prism-media": "^1.3.5"
+    "@metro-labs/core": "workspace:*",
+    "discord.js": "^14.26.4"
   },
   "devDependencies": {
-    "@stage-labs/config": "0.1.0-beta.2",
+    "@stage-labs/config": "0.1.0-beta.3",
     "eslint": "^10.3.0",
     "knip": "^6.15.0",
     "madge": "^8.0.0",

package/runtime/node_modules/@metro-labs/discord-bot/src/accounts.ts

@@ -1,37 +1,22 @@
 import { Client } from 'discord.js';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
 import {
   makeAccountStore,
   resolveAccountId,
-} from '@metro-labs/mcp/stations/account-store';
-import { Line } from '@metro-labs/mcp/lines';
-import { emit } from './wire.js';
+} from '@metro-labs/core/stations/account-store';
+import { Line } from '@metro-labs/core/lines';
 import { API } from './api-base.js';
 
-const ACCOUNTS_FILE =
-  process.env.DISCORD_BOT_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'discord-bot-accounts.json');
-
 export interface AccountConfig {
   id: string;
   token: string;
-  owner?: string;
 }
 
 export const { loadAccounts } = makeAccountStore<AccountConfig>({
   prefix: 'discord-bot',
-  file: ACCOUNTS_FILE,
-  allowlistEnv: ['DISCORD_BOT_ONLY_ACCOUNTS', 'DISCORD_BOT_ACCOUNTS'],
   validate(raw, die) {
-    const seen = new Set<string>();
-    for (const a of raw) {
-      if (!a.id) die('account missing id');
+    for (const a of raw)
       if (!a.token || typeof a.token !== 'string')
         die(`account '${a.id}' missing token`);
-      if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
-      seen.add(a.id);
-    }
   },
 });
 
@@ -71,17 +56,12 @@ export async function rest<T = unknown>(
   };
   if (body !== undefined && !isForm)
     headers['Content-Type'] = 'application/json';
-  emit({ op: 'log', text: `discord-bot[${accountId}] api ${method} ${path}` });
   const res = await fetch(`${API}${path}`, {
     method,
     headers,
     body: restBody(body, isForm),
     signal: AbortSignal.timeout(30_000),
   });
-  emit({
-    op: 'log',
-    text: `discord-bot[${accountId}] api ${method} ${path} -> ${res.status}`,
-  });
   if (!res.ok) {
     const text = await res.text().catch(() => '');
     throw new Error(`discord-bot ${method} ${path}: ${res.status} ${text}`);