@stage-labs/metro 0.1.0-beta.237 → 0.1.0-beta.239

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.237",
+  "version": "0.1.0-beta.239",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.237",
+  "version": "0.1.0-beta.239",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

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

@@ -52,7 +52,7 @@ import type { StationName } from '@metro-labs/core/station-names';
 import { startUploadReaper } from '../files/upload-store.js';
 import { startAttachReaper } from '../files/attach-reaper.js';
 import { startCloudWatchPublisher } from '../server/cloudwatch.js';
-import { isCallEvent, onCallEvent } from '../voice/calls.js';
+import { isCallEvent, leaveCallsForShutdown, onCallEvent, sweepLeftoverCalls } from '../voice/calls.js';
 
 installCrashGuard();
 acquireLock(join(STATE_DIR, '.tail-lock'));
@@ -137,6 +137,7 @@ installBearerSessions(agentsDir(), localOwner);
   await materializeFrom(fileSource);
   forgetOrphans(knownAccounts());
   supervisor.start();
+  sweepLeftoverCalls();
   const metroMcp = await createMetroMcp({ liveEvents: liveEvents() });
   webhookServer = await startWebhookServer(
     emit,
@@ -196,6 +197,7 @@ async function shutdown(): Promise<void> {
   if (shuttingDown) return;
   shuttingDown = true;
   log.info('dispatcher shutting down');
+  const leaving = leaveCallsForShutdown();
   unwatchSession();
   tunnel?.stop();
   if (webhookServer) {
@@ -211,6 +213,7 @@ async function shutdown(): Promise<void> {
       }),
     ]);
   }
+  await leaving;
   await supervisor.stop();
   process.exit(exitCode);
 }

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

@@ -10,6 +10,7 @@ const OFFER_WAIT_MS = 45_000;
 const LONGEST_CALL_MS = 60 * 60_000;
 const CONTEXT_MESSAGES = 12;
 const CONTEXT_CHARS = 400;
+const LEAVE_RETRY_MS = 3_000;
 
 interface CallStart {
   line: string;
@@ -21,7 +22,7 @@ interface CallStart {
 
 const str = (value: unknown): string => (typeof value === 'string' ? value : '');
 
-async function trainCall(action: string, args: Record<string, unknown>): Promise<unknown> {
+export async function trainCall(action: string, args: Record<string, unknown>): Promise<unknown> {
   const answer = await forwardTrainCall('xmtp', action, args);
   if (answer.error !== undefined) throw new Error(answer.error);
   return answer.result;
@@ -57,6 +58,7 @@ export class Call {
   private timer: ReturnType<typeof setTimeout> | null = null;
   private longest: ReturnType<typeof setTimeout>;
   private over = false;
+  private left: Promise<void> = Promise.resolve();
 
   constructor(
     readonly start: CallStart,
@@ -93,11 +95,16 @@ export class Call {
       this.answer(this.start.callerPeer, raw.sdp).catch((err: unknown) => {
         this.hangUp(`answering failed: ${errMsg(err)}`);
       });
-    else if (raw.kind === 'leave' && fromCaller) this.end('the caller hung up', false);
+    else if (raw.kind === 'leave' && fromCaller) this.hangUp('the caller hung up');
   }
 
   hangUp(reason: string): void {
-    this.end(reason, true);
+    this.end(reason);
+  }
+
+  leave(reason: string): Promise<void> {
+    this.end(reason);
+    return this.left;
   }
 
   private async answer(to: string, offer: string): Promise<void> {
@@ -111,6 +118,7 @@ export class Call {
       },
     });
     const sdp = await this.peer.answer(offer);
+    if (this.over) return;
     await this.signal({ kind: 'answer', callId: this.start.callId, from: this.selfPeer, to, sdp });
   }
 
@@ -124,13 +132,15 @@ export class Call {
     return trainCall('callSignal', { line: this.start.line, signal });
   }
 
-  private end(reason: string, sendLeave: boolean): void {
+  private end(reason: string): void {
     if (this.over) return;
     this.over = true;
     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.wrapUp(reason, sendLeave)
+    this.left = this.sendLeave();
+    this.left
+      .then(() => this.wrapUp(reason))
       .catch((err: unknown) => {
         log.warn({ err: errMsg(err) }, 'voice: wrapping up the call failed');
       })
@@ -139,16 +149,26 @@ export class Call {
       });
   }
 
-  private async wrapUp(reason: string, sendLeave: boolean): Promise<void> {
-    if (sendLeave)
-      await this.signal({ kind: 'leave', callId: this.start.callId, from: this.selfPeer }).catch((err: unknown) => {
-        log.warn({ err: errMsg(err) }, 'voice: could not send the hang-up');
+  private async sendLeave(): Promise<void> {
+    const leave = { kind: 'leave', callId: this.start.callId, from: this.selfPeer };
+    try {
+      await this.signal(leave);
+    } 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) => {
+        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();
     const notes = await this.talk.finish();
     const minutes = Math.max(1, Math.round((Date.now() - this.startedAt) / 60_000));
-    if (notes !== null) await trainCall('send', { line: this.start.line, text: `Call notes (${String(minutes)} min):\n${notes}` });
-    else if (!reason.startsWith('the caller') && reason !== 'no offer arrived')
-      await trainCall('send', { line: this.start.line, text: `The voice call ended: ${reason}.` });
+    const timing = this.talk.replyTime === null ? '' : `\n${this.talk.replyTime}`;
+    const failure = reason.startsWith('the caller') || reason === 'no offer arrived' ? null : `The voice call ended: ${reason}.`;
+    const text = [failure, notes === null ? null : `Call notes (${String(minutes)} min):\n${notes}${timing}`].filter((part) => part !== null).join('\n\n');
+    if (text !== '') await trainCall('send', { line: this.start.line, text });
   }
 }

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

@@ -2,11 +2,15 @@ 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 } from './call.js';
+import { Call, trainCall } from './call.js';
 import { readVoice, voiceReady } from './store.js';
 
-const INVITE_FRESH_MS = 60_000;
+const RING_MS = 40_000;
 const CALL_TYPES = new Set(['callInvite', 'callSignal']);
+const SHUTDOWN_LEAVE_MS = 2_000;
+const SWEEP_FIRST_MS = 5_000;
+const SWEEP_EVERY_MS = 10_000;
+const SWEEP_TRIES = 12;
 
 let current: Call | null = null;
 
@@ -17,26 +21,43 @@ const contentTypeOf = (env: TrainEvent): string => str(record(env.payload).conte
 
 export const isCallEvent = (env: TrainEvent): boolean => CALL_TYPES.has(contentTypeOf(env));
 
-function refusal(env: TrainEvent, line: string, from: string): string | null {
-  if (current !== null) return 'already in a call';
-  const sent = Date.parse(str(env.ts));
-  if (Number.isNaN(sent) || Date.now() - sent > INVITE_FRESH_MS) return 'the invite is too old';
+const sameCaller = (call: Call, 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';
   return null;
 }
 
+function decline(line: string, callId: string): void {
+  trainCall('callSignal', { line, signal: { kind: 'decline', callId } }).catch((err: unknown) => {
+    log.warn({ line, err: errMsg(err) }, 'voice: could not decline a call');
+  });
+}
+
+function ringing(env: TrainEvent): boolean {
+  const sent = Date.parse(str(env.ts));
+  return !Number.isNaN(sent) && Date.now() - sent < RING_MS;
+}
+
 function invite(env: TrainEvent, body: Record<string, unknown>): void {
   const line = str(env.line);
   const from = str(env.from);
   const callId = str(body.callId);
   const callerPeer = str(body.from);
-  if (callId === '' || callerPeer === '') return;
-  const refused = refusal(env, line, from);
+  if (callId === '' || callerPeer === '' || current?.start.callId === callId) return;
+  if (!ringing(env)) {
+    log.info({ line }, 'voice: an invite came in after the caller stopped ringing, not answered');
+    return;
+  }
+  const refused = refusal(line, from);
   if (refused !== null) {
-    log.info({ line, reason: refused }, 'voice: a call came in and is not answered');
+    log.info({ line, reason: refused }, 'voice: a call came in and is declined');
+    decline(line, callId);
     return;
   }
+  current?.hangUp('the caller started a new call');
   const callerName = str(env.from_display_name) || str(env.from_name) || 'the caller';
   const call = new Call({ line, from, callerName, callId, callerPeer }, readVoice(), () => {
     if (current === call) current = null;
@@ -52,3 +73,57 @@ export function onCallEvent(env: TrainEvent): void {
   if (contentTypeOf(env) === 'callInvite') invite(env, body);
   else if (current !== null && env.line === current.start.line) current.signalled(body);
 }
+
+export function leaveCallsForShutdown(): Promise<void> {
+  if (current === null) return Promise.resolve();
+  const leaving = current.leave('Metro stopped or restarted');
+  const capped = new Promise<void>((resolve) => {
+    setTimeout(resolve, SHUTDOWN_LEAVE_MS).unref();
+  });
+  return Promise.race([leaving, capped]);
+}
+
+interface Leftover {
+  line: string;
+  callId: string;
+  peer: string;
+}
+
+function leftoversOf(result: unknown): Leftover[] {
+  const rows = isRecord(result) && Array.isArray(result.calls) ? result.calls : [];
+  return rows
+    .map((row) => record(row))
+    .map((row) => ({ line: str(row.line), callId: str(row.callId), peer: str(row.peer) }))
+    .filter((row) => row.line !== '' && row.callId !== '' && row.peer !== '');
+}
+
+export async function leaveLeftoverCalls(): Promise<number> {
+  const leftovers = leftoversOf(await trainCall('callLeftovers', {}));
+  let left = 0;
+  for (const { line, callId, peer } of leftovers) {
+    if (current?.start.callId === callId) continue;
+    try {
+      await trainCall('callSignal', { line, signal: { kind: 'leave', callId, from: peer } });
+      log.info({ line, callId }, 'voice: left a call this box was still in');
+      left += 1;
+    } catch (err) {
+      log.warn({ line, err: errMsg(err) }, 'voice: could not leave a call this box was still in');
+    }
+  }
+  return left;
+}
+
+function sweep(tries: number, delayMs: number): void {
+  setTimeout(() => {
+    leaveLeftoverCalls().catch((err: unknown) => {
+      const reason = errMsg(err);
+      if (reason.startsWith('no train named')) return;
+      if (tries > 1) sweep(tries - 1, SWEEP_EVERY_MS);
+      else log.warn({ err: reason }, 'voice: could not check for calls left open');
+    });
+  }, delayMs).unref();
+}
+
+export function sweepLeftoverCalls(): void {
+  sweep(SWEEP_TRIES, SWEEP_FIRST_MS);
+}

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

@@ -26,14 +26,19 @@ const charsOf = (msg: Record<string, unknown>): number => {
   return isRecord(alignment) && Array.isArray(alignment.chars) ? alignment.chars.length : 0;
 };
 
+const MAX_REASON = 300;
+
 export class Utterance {
   private readonly ws: WebSocket;
   private readonly outbox: string[] = [];
   private listener: Voiced | null = null;
   private carry = 0;
   private closed = false;
+  private aborted = false;
+  private voiced = false;
+  private refusal: string | null = null;
 
-  constructor(apiKey: string, voiceId: string) {
+  constructor(apiKey: string, voiceId: string, failed: (reason: string) => void) {
     this.ws = new WebSocket(ttsUrl(voiceId), { headers: { 'xi-api-key': apiKey } });
     this.ws.on('open', () => {
       this.ws.send(JSON.stringify({ text: ' ' }));
@@ -43,12 +48,15 @@ export class Utterance {
       this.onMessage(wsText(data));
     });
     this.ws.on('error', (err) => {
+      this.refusal ??= errMsg(err);
       log.warn({ err: errMsg(err) }, 'voice: text to speech connection error');
     });
-    this.ws.on('close', () => {
+    this.ws.on('close', (code, why) => {
       this.closed = true;
       this.listener?.done();
       this.listener = null;
+      const reason = this.refusal ?? (code === 1000 ? null : (why.toString() || `closed (${String(code)})`));
+      if (!this.aborted && !this.voiced && reason !== null) failed(reason.slice(0, MAX_REASON));
     });
   }
 
@@ -69,6 +77,7 @@ export class Utterance {
   }
 
   abort(): void {
+    this.aborted = true;
     this.listener = null;
     this.ws.terminate();
   }
@@ -82,10 +91,14 @@ export class Utterance {
   private onMessage(raw: string): void {
     const msg = parsed(raw);
     if (typeof msg.audio === 'string' && msg.audio !== '') {
+      this.voiced = true;
       const pcm = pcmOf(Buffer.from(msg.audio, 'base64'));
       const up = upsample2(pcm, this.carry);
       this.carry = pcm.at(-1) ?? this.carry;
       this.listener?.audio(up, charsOf(msg));
-    } else if (msg.isFinal !== true) log.warn({ msg: raw.slice(0, 300) }, 'voice: text to speech said');
+    } else if (msg.isFinal !== true) {
+      if (typeof msg.message === 'string' && msg.message !== '') this.refusal ??= msg.message;
+      log.warn({ msg: raw.slice(0, MAX_REASON) }, 'voice: text to speech said');
+    }
   }
 }

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

@@ -6,7 +6,7 @@ import { Utterance } from './speech.js';
 import { Chunker } from './speakable.js';
 import { brainModel, voiceIdOf, type VoiceConfig } from './store.js';
 
-const BARGE_MIN_CHARS = 4;
+const BARGE_MIN_WORDS = 2;
 const NOTES_WAIT_MS = 60_000;
 const NOTES_PROMPT =
   '[The call has ended. Write short call notes for the chat: what was discussed, what was decided and what you will follow up on. Plain text, at most 6 short lines, no title and no greeting. Reply with the notes only.]';
@@ -17,10 +17,14 @@ interface Reply {
   heard: number;
   chunker: Chunker;
   askedAt: number | null;
+  saidAt: number | null;
   firstText: number | null;
   firstAudio: number | null;
+  firstPlayed: number | null;
 }
 
+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);
 
@@ -43,11 +47,15 @@ export class Talk implements Thinking {
   private muted = false;
   private busy = false;
   private askedAt: number | null = null;
+  private saidAt: number | null = null;
+  private lastHeardAt: number | null = null;
+  private readonly delays: number[] = [];
   private notes: ((text: string) => void) | null = null;
   private notesStarted = false;
   private live = false;
   private finished = false;
   private heardCaller = false;
+  private spoke = false;
 
   constructor(
     private readonly cfg: VoiceConfig,
@@ -76,7 +84,7 @@ export class Talk implements Thinking {
         this.ended(reason);
       },
     });
-    this.spare = new Utterance(cfg.apiKey, voiceIdOf(cfg));
+    this.spare = this.utterance();
   }
 
   prime(context: string): void {
@@ -86,7 +94,7 @@ export class Talk implements Thinking {
 
   connect(): void {
     this.live = true;
-    this.spare ??= new Utterance(this.cfg.apiKey, voiceIdOf(this.cfg));
+    this.spare ??= this.utterance();
     this.player.start();
   }
 
@@ -115,8 +123,19 @@ export class Talk implements Thinking {
     this.busy = true;
     if (this.notes !== null) this.notesStarted = true;
     if (this.notes !== null || this.finished) return;
-    this.reply = { utterance: this.takeUtterance(), said: '', heard: 0, chunker: new Chunker(), askedAt: this.askedAt, firstText: null, firstAudio: null };
+    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 {
@@ -158,14 +177,15 @@ export class Talk implements Thinking {
   }
 
   private takeUtterance(): Utterance {
-    const ready = this.spare?.usable === true ? this.spare : new Utterance(this.cfg.apiKey, voiceIdOf(this.cfg));
-    this.spare = this.live ? new Utterance(this.cfg.apiKey, voiceIdOf(this.cfg)) : null;
+    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);
       },
@@ -176,6 +196,13 @@ export class Talk implements Thinking {
     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} `;
@@ -187,32 +214,46 @@ export class Talk implements Thinking {
     if (this.reply !== null) this.reply.heard += chars;
   }
 
+  get replyTime(): string | null {
+    if (this.delays.length === 0) return null;
+    const sorted = [...this.delays].sort((a, b) => a - b);
+    const middle = sorted[Math.floor(sorted.length / 2)] ?? 0;
+    return `Reply time, from your last word heard to my first word sent: about ${(middle / 1000).toFixed(1)} s (middle of ${String(sorted.length)}).`;
+  }
+
   private firstPlayed(): void {
     const reply = this.reply;
-    if (reply?.askedAt != null) log.info({ firstPlayed: since(reply.askedAt, performance.now()) }, 'voice: first reply audio sent to the caller');
+    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 partial(text: string): void {
-    if (text.replace(/\s/g, '').length < BARGE_MIN_CHARS || this.muted) return;
-    if (!this.player.busy && !this.busy) return;
-    const reply = this.reply;
-    this.cut = heardNote(reply);
-    reply?.utterance.abort();
+  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 {
     this.heardCaller = true;
+    if (this.interrupts(text)) this.cutOff();
     const note = this.cut;
-    const now = this.busy || note !== null;
+    const now = this.muted;
     this.cut = null;
-    if (now && !this.muted) {
-      this.reply?.utterance.abort();
-      this.player.clear();
-      this.muted = true;
-    }
     this.askedAt = performance.now();
+    this.saidAt = this.lastHeardAt ?? this.askedAt;
+    this.lastHeardAt = null;
     this.busy = true;
     this.brain.tell(note === null ? text : `${note}\n${text}`, now);
   }

package/runtime/node_modules/@metro-labs/xmtp/src/actions.ts

@@ -14,6 +14,7 @@ import { resolveMsgId } from './wire.js';
 import { emitOutbound } from './emit.js';
 import { CallSignalCodec, FrameCodec, PollCodec, buildPollContent, encodeDeleteMessage } from './codecs.js';
 import { buildFrameContent } from './frames.js';
+import { callLeftovers } from './call-leftovers.js';
 import { convHandlers } from './actions-conv.js';
 import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
 import { TrainError } from '@metro-labs/core/train-error';
@@ -233,6 +234,7 @@ const handlers: Record<string, (id: string, args: Args) => Promise<void>> = {
   reply,
   delete: remove,
   callSignal,
+  callLeftovers: (id) => callLeftovers(id),
   sendAttachment,
   sendImage,
   ...convHandlers,

package/runtime/node_modules/@metro-labs/xmtp/src/call-leftovers.ts

@@ -0,0 +1,47 @@
+import type { DecodedMessage } from '@xmtp/node-sdk';
+import { isRecord } from '@metro-labs/core/is-record';
+import { TrainError } from '@metro-labs/core/train-error';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { accounts, lineOf, type Account } from './accounts.js';
+import { isCallSignal } from './codecs.js';
+
+const CALL_WINDOW_MS = 2 * 60 * 60_000;
+
+interface Leftover {
+  line: string;
+  callId: string;
+  peer: string;
+}
+
+function ownSignal(acct: Account, m: DecodedMessage): Record<string, unknown> | null {
+  if (m.senderInboxId !== acct.inboxId || !isCallSignal(m)) return null;
+  return isRecord(m.content) ? m.content : null;
+}
+
+function openJoins(acct: Account, line: string, messages: DecodedMessage[]): Leftover[] {
+  const open = new Map<string, string>();
+  for (const m of messages) {
+    const signal = ownSignal(acct, m);
+    if (signal === null || typeof signal.from !== 'string' || typeof signal.callId !== 'string') continue;
+    if (signal.kind === 'join') open.set(signal.from, signal.callId);
+    else if (signal.kind === 'leave') open.delete(signal.from);
+  }
+  return [...open].map(([peer, callId]) => ({ line, callId, peer }));
+}
+
+async function leftoversOf(acct: Account, sinceNs: bigint): Promise<Leftover[]> {
+  const found: Leftover[] = [];
+  for (const conv of await acct.client.conversations.list()) {
+    const messages = await conv.messages({ sentAfterNs: sinceNs, direction: 0 });
+    found.push(...openJoins(acct, lineOf(acct.cfg.id, conv.id), messages));
+  }
+  return found;
+}
+
+export async function callLeftovers(id: string): Promise<void> {
+  if (accounts.size === 0) throw new TrainError('UNAVAILABLE', 'no XMTP account is ready yet');
+  const sinceNs = BigInt(Date.now() - CALL_WINDOW_MS) * 1_000_000n;
+  const calls: Leftover[] = [];
+  for (const acct of accounts.values()) calls.push(...(await leftoversOf(acct, sinceNs)));
+  respond(id, { result: { calls } });
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.237"
+  "version": "0.1.0-beta.239"
 }