@stage-labs/metro 0.1.0-beta.263 → 0.1.0-beta.265

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

@@ -1,9 +1,13 @@
 import { randomUUID } from 'node:crypto';
+import type { CallRoute } from '@metro-labs/core/call';
 import { errMsg, log } from '@metro-labs/core/log';
 import { isRecord } from '@metro-labs/core/is-record';
 import { forwardTrainCall } from '../stations/train-call.js';
 import { CallApprovals } from './approvals.js';
-import { Peer } from './peer.js';
+import type { Playback } from './audio.js';
+import { Peer, type PeerEvents } from './peer.js';
+import { SharedTalk } from './shared-talk.js';
+import { endSharedCall, hearSharedCall, openSharedCall, sharedCallsSelected, type SharedCallTransport } from './shared.js';
 import { Talk } from './talk.js';
 import type { VoiceConfig } from './store.js';
 
@@ -12,8 +16,11 @@ const LONGEST_CALL_MS = 60 * 60_000;
 const CONTEXT_MESSAGES = 12;
 const CONTEXT_CHARS = 400;
 const LEAVE_RETRY_MS = 3_000;
+const SIGNAL_WAIT_MS = 2_000;
 
-interface CallStart {
+export interface CallStart {
+  agentId: string;
+  sourceId: string;
   line: string;
   lineName: string;
   direct: boolean;
@@ -23,6 +30,23 @@ interface CallStart {
   callerPeer: string;
 }
 
+type CallAudio = Pick<Talk, 'connect' | 'hear' | 'finish'>;
+type CallPeer = Pick<Peer, 'answer' | 'sendOpus' | 'close'>;
+type ContextStart = Omit<CallStart, 'agentId' | 'sourceId'>;
+
+export interface CallDependencies {
+  train: typeof trainCall;
+  peer(events: PeerEvents): CallPeer;
+  cli(cfg: VoiceConfig, out: Playback['send'], ended: (reason: string) => void, approvals: CallApprovals): CallAudio & Pick<Talk, 'prime'>;
+  shared(cfg: VoiceConfig, out: Playback['send'], ended: (reason: string) => void, heard: (text: string, sourceId: string) => void): CallAudio & SharedCallTransport;
+  selected: typeof sharedCallsSelected;
+  open: typeof openSharedCall;
+  heard: typeof hearSharedCall;
+  ended: typeof endSharedCall;
+  signalWaitMs: number;
+  leaveRetryMs: number;
+}
+
 const str = (value: unknown): string => (typeof value === 'string' ? value : '');
 
 export async function trainCall(action: string, args: Record<string, unknown>): Promise<unknown> {
@@ -31,20 +55,33 @@ export async function trainCall(action: string, args: Record<string, unknown>):
   return answer.result;
 }
 
-function speaker(row: Record<string, unknown>, start: CallStart): string {
+const dependencies: CallDependencies = {
+  train: trainCall,
+  peer: (events) => new Peer(events),
+  cli: (cfg, out, ended, approvals) => new Talk(cfg, out, ended, approvals),
+  shared: (cfg, out, ended, heard) => new SharedTalk(cfg, out, ended, heard),
+  selected: sharedCallsSelected,
+  open: openSharedCall,
+  heard: hearSharedCall,
+  ended: endSharedCall,
+  signalWaitMs: SIGNAL_WAIT_MS,
+  leaveRetryMs: LEAVE_RETRY_MS,
+};
+
+function speaker(row: Record<string, unknown>, start: ContextStart): string {
   if (row.self === true) return 'you';
   return row.from === start.from ? start.callerName : `another member (${str(row.from)})`;
 }
 
-function contextLine(row: unknown, start: CallStart): string | null {
+function contextLine(row: unknown, start: ContextStart): string | null {
   if (!isRecord(row) || typeof row.text !== 'string' || row.text.startsWith('[call')) return null;
   const who = speaker(row, start);
   return `${str(row.ts).slice(11, 16)} ${who}: ${row.text.replace(/\s+/g, ' ').slice(0, CONTEXT_CHARS)}`;
 }
 
-async function recentChat(start: CallStart): Promise<string> {
+async function recentChat(start: CallStart, train: typeof trainCall): Promise<string> {
   try {
-    const result = await trainCall('read', { line: start.line, limit: CONTEXT_MESSAGES });
+    const result = await train('read', { line: start.line, limit: CONTEXT_MESSAGES });
     const rows = isRecord(result) && Array.isArray(result.messages) ? result.messages : [];
     return rows.map((row) => contextLine(row, start)).filter((l): l is string => l !== null).join('\n');
   } catch (err) {
@@ -53,12 +90,12 @@ async function recentChat(start: CallStart): Promise<string> {
   }
 }
 
-function where(start: CallStart): string {
+function where(start: ContextStart): string {
   if (start.lineName !== '') return `the group chat "${start.lineName}"`;
   return start.direct ? `your direct chat with ${start.callerName}` : 'a group chat with no name';
 }
 
-export function opening(start: CallStart, chat: string): string {
+export function opening(start: ContextStart, chat: string): string {
   const recent = chat === '' ? 'No earlier messages were found there.' : `Recent messages there before the call, oldest first (times in UTC):\n${chat}`;
   return [
     `[A voice call with ${start.callerName} is starting on Stage, in ${where(start)}.`,
@@ -70,49 +107,77 @@ export function opening(start: CallStart, chat: string): string {
 }
 
 export class Call {
+  readonly route: CallRoute;
   private readonly selfPeer = randomUUID();
   private readonly startedAt = Date.now();
-  private readonly talk: Talk;
-  private peer: Peer | null = null;
+  private readonly talk: CallAudio;
+  private readonly shared: SharedCallTransport | null;
+  private readonly prime: ((context: string) => void) | null;
+  private readonly deps: CallDependencies;
+  private peer: CallPeer | null = null;
   private timer: ReturnType<typeof setTimeout> | null = null;
-  private longest: ReturnType<typeof setTimeout>;
+  private readonly longest: ReturnType<typeof setTimeout>;
   private over = false;
+  private begun = false;
   private left: Promise<void> = Promise.resolve();
 
   constructor(
     readonly start: CallStart,
     cfg: VoiceConfig,
     private readonly onOver: () => void,
+    deps: Partial<CallDependencies> = {},
   ) {
-    const approvals = new CallApprovals(start.line, async (text) => {
-      await trainCall('send', { line: start.line, text });
-    });
-    this.talk = new Talk(
-      cfg,
-      (opus, timestamp, marker) => {
-        this.peer?.sendOpus(opus, timestamp, marker);
-      },
-      (reason) => {
-        this.hangUp(reason);
-      },
-      approvals,
-    );
+    this.deps = { ...dependencies, ...deps };
+    this.route = Object.freeze({ agentId: start.agentId, line: start.line, from: start.from, callId: start.callId, generation: randomUUID() });
+    const out: Playback['send'] = (opus, timestamp, marker) => {
+      if (this.over || this.peer === null) return Promise.reject(new Error('call audio is not connected'));
+      return this.peer.sendOpus(opus, timestamp, marker);
+    };
+    const ended = (reason: string): void => {
+      this.hangUp(reason);
+    };
+    if (this.deps.selected()) {
+      const shared = this.deps.shared(cfg, out, ended, (text, sourceId) => {
+        if (!this.over) this.deps.heard(this.route, text, sourceId);
+      });
+      this.talk = shared;
+      this.shared = shared;
+      this.prime = null;
+    } else {
+      const approvals = new CallApprovals(start.line, async (text) => {
+        await this.deps.train('send', { line: start.line, text });
+      });
+      const cli = this.deps.cli(cfg, out, ended, approvals);
+      this.talk = cli;
+      this.shared = null;
+      this.prime = (context) => {
+        cli.prime(context);
+      };
+    }
     this.longest = setTimeout(() => {
       this.hangUp('the call reached one hour');
     }, LONGEST_CALL_MS);
   }
 
   async begin(): Promise<void> {
+    if (this.over || this.begun) return;
+    this.begun = true;
     log.info({ line: this.start.line, callId: this.start.callId }, 'voice: answering a call');
-    recentChat(this.start)
-      .then((chat) => {
-        if (!this.over) this.talk.prime(opening(this.start, chat));
-      })
-      .catch((err: unknown) => {
+    if (this.shared !== null) {
+      if (!this.deps.open(this.route, this.start.sourceId, this.shared)) throw new Error('the shared conversation is unavailable');
+    } else {
+      recentChat(this.start, this.deps.train).then((chat) => {
+        if (!this.over) this.prime?.(opening(this.start, chat));
+      }).catch((err: unknown) => {
         log.warn({ err: errMsg(err) }, 'voice: could not start the agent on the call');
       });
+    }
     await this.signal({ kind: 'join', callId: this.start.callId, from: this.selfPeer });
-    this.timer = setTimeout(() => {
+    if (this.over) {
+      await this.sendLeave();
+      return;
+    }
+    if (this.peer === null) this.timer = setTimeout(() => {
       this.hangUp('no offer arrived');
     }, OFFER_WAIT_MS);
   }
@@ -138,9 +203,9 @@ export class Call {
 
   private async answer(to: string, offer: string): Promise<void> {
     if (this.timer !== null) clearTimeout(this.timer);
-    this.peer = new Peer({
+    this.peer = this.deps.peer({
       audio: (opus) => {
-        this.talk.hear(opus);
+        if (!this.over) this.talk.hear(opus);
       },
       state: (state) => {
         this.stateChanged(state);
@@ -152,13 +217,14 @@ export class Call {
   }
 
   private stateChanged(state: string): void {
+    if (this.over) return;
     log.info({ state, afterMs: Date.now() - this.startedAt }, 'voice: call connection');
     if (state === 'connected') this.talk.connect();
     else if (state === 'failed' || state === 'closed') this.hangUp(`the connection ${state}`);
   }
 
   private signal(signal: Record<string, unknown>): Promise<unknown> {
-    return trainCall('callSignal', { line: this.start.line, signal });
+    return this.deps.train('callSignal', { line: this.start.line, signal });
   }
 
   private end(reason: string): void {
@@ -167,34 +233,42 @@ export class Call {
     if (this.timer !== null) clearTimeout(this.timer);
     clearTimeout(this.longest);
     log.info({ reason, seconds: Math.round((Date.now() - this.startedAt) / 1000) }, 'voice: call over');
-    this.left = this.sendLeave();
-    this.left
-      .then(() => this.wrapUp(reason))
-      .catch((err: unknown) => {
-        log.warn({ err: errMsg(err) }, 'voice: wrapping up the call failed');
-      })
-      .finally(() => {
-        this.onOver();
-      });
+    this.talk.finish();
+    this.peer?.close();
+    if (this.shared !== null) this.deps.ended(this.route);
+    this.onOver();
+    this.left = this.sendLeave().then(async () => {
+      if (this.shared !== null || reason.startsWith('the caller') || reason === 'no offer arrived') return;
+      await this.deps.train('send', { line: this.start.line, text: `The voice call ended: ${reason}.` });
+    }).catch((err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'voice: wrapping up the call failed');
+    });
   }
 
   private async sendLeave(): Promise<void> {
-    const leave = { kind: 'leave', callId: this.start.callId, from: this.selfPeer };
     try {
-      await this.signal(leave);
+      await this.leaveOnce();
     } catch (err) {
       log.warn({ err: errMsg(err) }, 'voice: could not send the hang-up, trying once more');
-      await new Promise((r) => setTimeout(r, LEAVE_RETRY_MS));
-      await this.signal(leave).catch((again: unknown) => {
+      await new Promise((r) => setTimeout(r, this.deps.leaveRetryMs));
+      await this.leaveOnce().catch((again: unknown) => {
         log.warn({ err: errMsg(again) }, 'voice: could not send the hang-up; the next start sends it');
       });
     }
   }
 
-  private async wrapUp(reason: string): Promise<void> {
-    this.peer?.close();
-    this.talk.finish();
-    if (reason.startsWith('the caller') || reason === 'no offer arrived') return;
-    await trainCall('send', { line: this.start.line, text: `The voice call ended: ${reason}.` });
+  private async leaveOnce(): Promise<void> {
+    const leave = { kind: 'leave', callId: this.start.callId, from: this.selfPeer };
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const capped = new Promise<never>((_resolve, reject) => {
+      timer = setTimeout(() => {
+        reject(new Error('hang-up signal timed out'));
+      }, this.deps.signalWaitMs);
+    });
+    try {
+      await Promise.race([this.signal(leave), capped]);
+    } finally {
+      clearTimeout(timer);
+    }
   }
 }

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

@@ -1,9 +1,10 @@
+import { randomUUID } from 'node:crypto';
 import { errMsg, log } from '@metro-labs/core/log';
 import { isRecord } from '@metro-labs/core/is-record';
 import type { TrainEvent } from '@metro-labs/core/trains/protocol';
-import { lineReceives, mayApprove } from '../agents/map.js';
-import { Call, trainCall } from './call.js';
-import { readVoice, voiceReady } from './store.js';
+import { agentIdForLine, allowlistForLine, lineReceives, mayApprove, senderPermitted } from '../agents/map.js';
+import { Call, trainCall, type CallStart } from './call.js';
+import { readVoice, voiceReady, type VoiceConfig } from './store.js';
 
 const RING_MS = 40_000;
 const CALL_TYPES = new Set(['callInvite', 'callSignal']);
@@ -12,21 +13,30 @@ const SWEEP_FIRST_MS = 5_000;
 const SWEEP_EVERY_MS = 10_000;
 const SWEEP_TRIES = 12;
 
-let current: Call | null = null;
+type CallHandle = Pick<Call, 'start' | 'begin' | 'hangUp' | 'leave' | 'signalled'>;
+type MakeCall = (start: CallStart, cfg: VoiceConfig, onOver: () => void) => CallHandle;
+
+let current: CallHandle | null = null;
+const invites = new Set<string>();
+const INVITES_MAX = 256;
+const makeCall: MakeCall = (start, cfg, onOver) => new Call(start, cfg, onOver);
 
 const record = (value: unknown): Record<string, unknown> => (isRecord(value) ? value : {});
 const str = (value: unknown): string => (typeof value === 'string' ? value : '');
 
 const contentTypeOf = (env: TrainEvent): string => str(record(env.payload).contentType);
+const sourceIdOf = (env: TrainEvent): string => str(env.message_id) || str(env.id) || randomUUID();
+const callerNameOf = (env: TrainEvent): string => str(env.from_display_name) || str(env.from_name) || 'the caller';
 
 export const isCallEvent = (env: TrainEvent): boolean => CALL_TYPES.has(contentTypeOf(env));
 
-const sameCaller = (call: Call, line: string, from: string): boolean => call.start.line === line && call.start.from === from;
+const sameCaller = (call: CallHandle, line: string, from: string): boolean => call.start.line === line && call.start.from === from;
 
 function refusal(line: string, from: string): string | null {
   if (current !== null && !sameCaller(current, line, from)) return 'already in a call';
   if (!voiceReady(readVoice())) return 'voice is off or has no API key on the Voice page';
-  if (!lineReceives(line) || !mayApprove(line, from)) return 'the caller is not someone who can approve for this channel';
+  if (!lineReceives(line) || !mayApprove(line, from) || !senderPermitted(allowlistForLine(line), from)) return 'the caller is not someone who can approve for this channel';
+  if (agentIdForLine(line) === undefined) return 'the channel does not belong to this agent';
   return null;
 }
 
@@ -38,15 +48,17 @@ function decline(line: string, callId: string): void {
 
 function ringing(env: TrainEvent): boolean {
   const sent = Date.parse(str(env.ts));
-  return !Number.isNaN(sent) && Date.now() - sent < RING_MS;
+  const age = Date.now() - sent;
+  return Number.isFinite(age) && age >= -5_000 && age < RING_MS;
 }
 
-function invite(env: TrainEvent, body: Record<string, unknown>): void {
+function invite(env: TrainEvent, body: Record<string, unknown>, create: MakeCall): void {
   const line = str(env.line);
   const from = str(env.from);
   const callId = str(body.callId);
   const callerPeer = str(body.from);
-  if (callId === '' || callerPeer === '' || current?.start.callId === callId) return;
+  const key = JSON.stringify([line, from, callId]);
+  if (callId === '' || callerPeer === '' || invites.has(key)) return;
   if (!ringing(env)) {
     log.info({ line }, 'voice: an invite came in after the caller stopped ringing, not answered');
     return;
@@ -57,10 +69,15 @@ function invite(env: TrainEvent, body: Record<string, unknown>): void {
     decline(line, callId);
     return;
   }
+  const agentId = agentIdForLine(line);
+  if (agentId === undefined) return;
+  invites.add(key);
+  if (invites.size > INVITES_MAX) invites.delete(invites.values().next().value ?? '');
   current?.hangUp('the caller started a new call');
-  const callerName = str(env.from_display_name) || str(env.from_name) || 'the caller';
-  const start = { line, lineName: str(env.line_name), direct: env.is_private === true, from, callerName, callId, callerPeer };
-  const call = new Call(start, readVoice(), () => {
+  const callerName = callerNameOf(env);
+  const sourceId = sourceIdOf(env);
+  const start = { agentId, sourceId, line, lineName: str(env.line_name), direct: env.is_private === true, from, callerName, callId, callerPeer };
+  const call = create(start, readVoice(), () => {
     if (current === call) current = null;
   });
   current = call;
@@ -69,10 +86,19 @@ function invite(env: TrainEvent, body: Record<string, unknown>): void {
   });
 }
 
-export function onCallEvent(env: TrainEvent): void {
+function authenticated(env: TrainEvent): boolean {
+  if (env.sender_verified === false || (env.station !== undefined && env.station !== 'xmtp')) return false;
+  const line = str(env.line);
+  const match = /^metro:\/\/xmtp\/([^/]+)\/[^/]+$/.exec(line);
+  return match !== null && str(env.from).startsWith(`metro://xmtp/${String(match[1])}/user/`) && str(env.from).split('/').length === 6;
+}
+
+export function onCallEvent(env: TrainEvent, train = 'xmtp', create: MakeCall = makeCall): void {
+  if (train !== 'xmtp' || !authenticated(env)) return;
   const body = record(record(env.payload).call);
-  if (contentTypeOf(env) === 'callInvite') invite(env, body);
-  else if (current !== null && env.line === current.start.line) current.signalled(body);
+  if (contentTypeOf(env) === 'callInvite') invite(env, body, create);
+  else if (contentTypeOf(env) === 'callSignal' && current !== null && sameCaller(current, str(env.line), str(env.from)))
+    current.signalled(body);
 }
 
 export function leaveCallsForShutdown(): Promise<void> {

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

@@ -7,7 +7,7 @@ const GATHER_MS = 2_500;
 const OPUS_PT = 111;
 const MEDIA = JSON.stringify({ audio: true, video: false, screen: false });
 
-interface PeerEvents {
+export interface PeerEvents {
   audio(opus: Buffer): void;
   state(state: string): void;
 }
@@ -34,6 +34,7 @@ export class Peer {
   private readonly channel: RTCDataChannel;
   private sender: RTCRtpSender | null = null;
   private sequence = Math.floor(Math.random() * 0xffff);
+  private closed = false;
 
   constructor(private readonly events: PeerEvents) {
     this.channel = this.pc.createDataChannel('media', { negotiated: true, id: 0 });
@@ -43,11 +44,11 @@ export class Peer {
     this.pc.onTrack.subscribe((track) => {
       if (track.kind === 'audio')
         track.onReceiveRtp.subscribe((rtp) => {
-          this.events.audio(rtp.payload);
+          if (!this.closed) this.events.audio(rtp.payload);
         });
     });
     this.pc.connectionStateChange.subscribe((state) => {
-      this.events.state(state);
+      if (!this.closed) this.events.state(state);
     });
   }
 
@@ -66,17 +67,17 @@ export class Peer {
     return sdp;
   }
 
-  sendOpus(payload: Buffer, timestamp: number, marker: boolean): void {
+  sendOpus(payload: Buffer, timestamp: number, marker: boolean): Promise<void> {
     const sender = this.sender;
-    if (sender === null) return;
+    if (this.closed || sender === null) return Promise.reject(new Error('call audio transport is closed'));
     this.sequence = (this.sequence + 1) & 0xffff;
     const header = new RtpHeader({ payloadType: OPUS_PT, sequenceNumber: this.sequence, timestamp, marker });
-    sender.sendRtp(new RtpPacket(header, payload)).catch((err: unknown) => {
-      log.debug({ err: errMsg(err) }, 'voice: an audio packet was not sent');
-    });
+    return sender.sendRtp(new RtpPacket(header, payload));
   }
 
   close(): void {
+    if (this.closed) return;
+    this.closed = true;
     this.pc.close().catch((err: unknown) => {
       log.debug({ err: errMsg(err) }, 'voice: closing the call connection failed');
     });

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

@@ -9,7 +9,7 @@ const CHUNK_SAMPLES = STT_RATE / 10;
 const HELD_SAMPLES = STT_RATE * 2;
 export const VAD_SILENCE_SECS = 0.5;
 
-interface Heard {
+export interface Heard {
   partial(text: string): void;
   committed(text: string): void;
   failed(reason: string): void;
@@ -54,6 +54,7 @@ export class Scribe {
   private readonly ws: WebSocket;
   private buffer: Int16Array[] = [];
   private buffered = 0;
+  private closed = false;
 
   constructor(apiKey: string, language: string | null, private readonly heard: Heard) {
     this.ws = new WebSocket(sttUrl(language), { headers: { 'xi-api-key': apiKey } });
@@ -61,14 +62,20 @@ export class Scribe {
       this.onMessage(wsText(data));
     });
     this.ws.on('error', (err) => {
+      if (this.closed) return;
       log.warn({ err: errMsg(err) }, 'voice: speech to text connection error');
     });
     this.ws.on('close', (code) => {
-      if (code !== 1000) this.heard.failed(`speech to text closed (${String(code)})`);
+      if (this.closed) return;
+      this.closed = true;
+      this.buffer = [];
+      this.buffered = 0;
+      this.heard.failed(`speech to text closed (${String(code)})`);
     });
   }
 
   send(pcm16k: Int16Array): void {
+    if (this.closed) return;
     this.buffer.push(pcm16k);
     this.buffered += pcm16k.length;
     while (this.buffered > HELD_SAMPLES) this.buffered -= this.buffer.shift()?.length ?? this.buffered;
@@ -87,10 +94,15 @@ export class Scribe {
   }
 
   close(): void {
-    this.ws.close(1000);
+    if (this.closed) return;
+    this.closed = true;
+    this.buffer = [];
+    this.buffered = 0;
+    this.ws.terminate();
   }
 
   private onMessage(raw: string): void {
+    if (this.closed) return;
     const msg = parsed(raw);
     const type = typeof msg.message_type === 'string' ? msg.message_type : '';
     const text = typeof msg.text === 'string' ? msg.text.trim() : '';

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

@@ -0,0 +1,85 @@
+import { randomUUID } from 'node:crypto';
+import { downsample3, OpusIn, type Playback } from './audio.js';
+import { Scribe, type Heard } from './scribe.js';
+import type { SharedCallTransport, SharedSpeechAction } from './shared.js';
+import { SpeechQueue } from './speech-queue.js';
+import { languageOf, type VoiceConfig } from './store.js';
+
+const BARGE_MIN_WORDS = 2;
+const wordsIn = (text: string): number => text.split(/\s+/).filter((word) => /\p{L}/u.test(word)).length;
+
+type MakeScribe = (heard: Heard) => Pick<Scribe, 'send' | 'close'>;
+
+export class SharedTalk implements SharedCallTransport {
+  private readonly opus = new OpusIn();
+  private readonly scribe: Pick<Scribe, 'send' | 'close'>;
+  private readonly speech: SpeechQueue;
+  private closed = false;
+
+  constructor(
+    cfg: VoiceConfig,
+    send: Playback['send'],
+    private readonly ended: (reason: string) => void,
+    heard: (text: string, sourceId: string) => void,
+    makeScribe: MakeScribe = (events) => new Scribe(cfg.apiKey, languageOf(cfg), events),
+    speech = new SpeechQueue(cfg, send),
+  ) {
+    this.speech = speech;
+    this.speech.whenFailed(() => {
+      this.stop('speech is unavailable');
+    });
+    this.scribe = makeScribe({
+      partial: (text) => {
+        this.barge(text);
+      },
+      committed: (text) => {
+        if (this.closed || text.trim() === '') return;
+        this.barge(text);
+        heard(text, randomUUID());
+      },
+      failed: (reason) => {
+        if (!this.closed) ended(reason);
+      },
+    });
+  }
+
+  enqueue(action: SharedSpeechAction): boolean {
+    return !this.closed && this.speech.enqueue(action);
+  }
+
+  cancel(): void {
+    this.speech.cancel();
+  }
+
+  terminate(): void {
+    this.stop('the shared conversation ended');
+  }
+
+  connect(): void {
+    if (!this.closed) this.speech.connect();
+  }
+
+  hear(packet: Buffer): void {
+    if (this.closed) return;
+    const pcm = this.opus.decode(packet);
+    if (pcm !== null) this.scribe.send(downsample3(pcm));
+  }
+
+  finish(): void {
+    if (this.closed) return;
+    this.closed = true;
+    this.speech.close();
+    this.scribe.close();
+    this.opus.close();
+  }
+
+  private stop(reason: string): void {
+    if (this.closed) return;
+    this.finish();
+    this.ended(reason);
+  }
+
+  private barge(text: string): void {
+    if (!this.closed && this.speech.busy && wordsIn(text) >= BARGE_MIN_WORDS) this.speech.cancel();
+  }
+}