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

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

@@ -6,7 +6,7 @@ import { elevenLabs, parsed, wsText } from './scribe.js';
 
 const TTS_MODEL = 'eleven_flash_v2_5';
 
-interface Voiced {
+export interface Voiced {
   audio(pcm48k: Int16Array, chars: number): void;
   done(): void;
 }
@@ -37,10 +37,12 @@ export class Utterance {
   private aborted = false;
   private voiced = false;
   private refusal: string | null = null;
+  private finished = false;
 
-  constructor(apiKey: string, voiceId: string, failed: (reason: string) => void) {
+  constructor(apiKey: string, voiceId: string, private readonly failed: (reason: string) => void) {
     this.ws = new WebSocket(ttsUrl(voiceId), { headers: { 'xi-api-key': apiKey } });
     this.ws.on('open', () => {
+      if (this.aborted) return;
       this.ws.send(JSON.stringify({ text: ' ' }));
       for (const line of this.outbox.splice(0)) this.ws.send(line);
     });
@@ -48,15 +50,14 @@ export class Utterance {
       this.onMessage(wsText(data));
     });
     this.ws.on('error', (err) => {
+      if (this.aborted || this.finished) return;
       this.refusal ??= errMsg(err);
       log.warn({ err: errMsg(err) }, 'voice: text to speech connection error');
     });
     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));
+      this.complete(reason);
     });
   }
 
@@ -65,7 +66,7 @@ export class Utterance {
   }
 
   attach(listener: Voiced): void {
-    this.listener = listener;
+    if (!this.aborted && !this.finished) this.listener = listener;
   }
 
   say(text: string): void {
@@ -77,28 +78,52 @@ export class Utterance {
   }
 
   abort(): void {
+    if (this.aborted) return;
     this.aborted = true;
     this.listener = null;
+    this.outbox.length = 0;
     this.ws.terminate();
   }
 
+  private complete(reason: string | null): void {
+    if (this.aborted || this.finished) return;
+    this.finished = true;
+    const listener = this.listener;
+    this.listener = null;
+    this.outbox.length = 0;
+    const failure = reason ?? (listener !== null && !this.voiced ? 'no audio received' : null);
+    if (failure !== null) this.failed(failure.slice(0, MAX_REASON));
+    else listener?.done();
+  }
+
   private post(msg: Record<string, unknown>): void {
+    if (this.aborted || this.closed || this.finished) return;
     const line = JSON.stringify(msg);
     if (this.ws.readyState === WebSocket.OPEN) this.ws.send(line);
     else this.outbox.push(line);
   }
 
+  private refused(msg: Record<string, unknown>, raw: string): void {
+    if (typeof msg.message === 'string' && msg.message !== '') this.refusal ??= msg.message;
+    log.warn({ msg: raw.slice(0, MAX_REASON) }, 'voice: text to speech said');
+  }
+
+  private audio(encoded: string, chars: number): void {
+    this.voiced = true;
+    const pcm = pcmOf(Buffer.from(encoded, 'base64'));
+    const up = upsample2(pcm, this.carry);
+    this.carry = pcm.at(-1) ?? this.carry;
+    this.listener?.audio(up, chars);
+  }
+
   private onMessage(raw: string): void {
+    if (this.aborted || this.finished) return;
     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) {
-      if (typeof msg.message === 'string' && msg.message !== '') this.refusal ??= msg.message;
-      log.warn({ msg: raw.slice(0, MAX_REASON) }, 'voice: text to speech said');
+    if (typeof msg.audio === 'string' && msg.audio !== '') this.audio(msg.audio, charsOf(msg));
+    else if (msg.isFinal !== true) this.refused(msg, raw);
+    if (this.refusal !== null || msg.isFinal === true) {
+      this.complete(this.refusal);
+      this.ws.close(1000);
     }
   }
 }

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

@@ -58,7 +58,7 @@ export class Talk implements Thinking {
 
   constructor(
     private readonly cfg: VoiceConfig,
-    out: (opus: Buffer, timestamp: number, marker: boolean) => void,
+    out: Playback['send'],
     private readonly ended: (reason: string) => void,
     private readonly approvals: CallApprovals,
   ) {
@@ -72,6 +72,9 @@ export class Talk implements Thinking {
     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) => {
@@ -88,10 +91,11 @@ export class Talk implements Thinking {
   }
 
   prime(context: string): void {
-    this.brain.tell(context);
+    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();
@@ -118,8 +122,8 @@ export class Talk implements Thinking {
   }
 
   turnStarted(): void {
-    this.muted = false;
     if (this.finished) return;
+    this.muted = false;
     this.reply = {
       utterance: this.takeUtterance(),
       said: '',
@@ -137,19 +141,20 @@ export class Talk implements Thinking {
 
   text(delta: string): void {
     const reply = this.reply;
-    if (this.muted || reply === null) return;
+    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 (reply === null || this.muted) return;
+    if (this.finished || reply === null || this.muted) return;
     this.speak(reply, reply.chunker.flush());
     reply.utterance.end();
     log.info(
@@ -171,6 +176,7 @@ export class Talk implements Thinking {
   }
 
   exited(reason: string): void {
+    if (this.finished) return;
     log.warn({ reason }, 'voice: the agent session for the call ended');
     this.ended(`agent session ${reason}`);
   }
@@ -183,13 +189,13 @@ export class Talk implements Thinking {
     ready.attach({
       audio: (pcm, chars) => {
         const current = reply();
-        if (current?.utterance !== ready) return;
+        if (this.finished || this.muted || current?.utterance !== ready) return;
         this.spoke = true;
         current.firstAudio ??= performance.now();
         this.player.push(pcm, chars);
       },
       done: () => {
-        this.player.finish();
+        if (!this.finished && !this.muted && this.reply?.utterance === ready) this.player.finish();
       },
     });
     return ready;
@@ -239,11 +245,13 @@ export class Talk implements Thinking {
   }
 
   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;

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.264"
+  "version": "0.1.0-beta.265"
 }

package/runtime/sdk-runner/node_modules/@metro-labs/core/package.json

@@ -9,6 +9,7 @@
     "./events": "./src/events.ts",
     "./is-record": "./src/is-record.ts",
     "./runner-activity": "./src/runner-activity.ts",
+    "./call": "./src/call.ts",
     "./secure-fs": "./src/secure-fs.ts",
     "./version": "./src/version.ts",
     "./train-error": "./src/train-error.ts",

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/call.ts

@@ -0,0 +1,81 @@
+import { isRecord } from './is-record.js';
+
+export const CALL_NOTICE = 'notifications/metro/call';
+export const CALL_STATE = 'notifications/metro/call_state';
+
+export interface CallState {
+  route: CallRoute | null;
+}
+
+export interface CallRoute {
+  agentId: string;
+  line: string;
+  from: string;
+  callId: string;
+  generation: string;
+}
+
+export interface SpeechTarget {
+  callId: string;
+  generation: string;
+  sourceId: string;
+}
+
+export interface CallSource {
+  route: CallRoute;
+  sourceId: string;
+}
+
+export type SpeechStatus = 'accepted' | 'queued' | 'started' | 'completed' | 'interrupted' | 'failed';
+
+export type CallNotice =
+  | { type: 'started'; route: CallRoute; sourceId: string }
+  | { type: 'heard'; route: CallRoute; sourceId: string; text: string }
+  | { type: 'ended'; route: CallRoute }
+  | { type: 'speech'; route: CallRoute; sourceId: string; actionId: string; status: SpeechStatus };
+
+const filled = (value: unknown): value is string => typeof value === 'string' && value.length > 0 && value.length <= 2048;
+
+export function callRoute(value: unknown): CallRoute | null {
+  if (!isRecord(value)) return null;
+  const { agentId, line, from, callId, generation } = value;
+  return filled(agentId) && filled(line) && filled(from) && filled(callId) && filled(generation)
+    ? { agentId, line, from, callId, generation }
+    : null;
+}
+
+export function callState(value: unknown): CallState | null {
+  if (!isRecord(value)) return null;
+  if (value.route === null) return { route: null };
+  const route = callRoute(value.route);
+  return route === null ? null : { route };
+}
+
+export function speechTarget(value: unknown): SpeechTarget | null {
+  if (!isRecord(value)) return null;
+  const { callId, generation, sourceId } = value;
+  return filled(callId) && filled(generation) && filled(sourceId) ? { callId, generation, sourceId } : null;
+}
+
+const STATUSES: readonly SpeechStatus[] = ['accepted', 'queued', 'started', 'completed', 'interrupted', 'failed'];
+
+const speechStatus = (value: unknown): SpeechStatus | null => STATUSES.find((status) => status === value) ?? null;
+
+function sourcedNotice(value: Record<string, unknown>, route: CallRoute, sourceId: string): CallNotice | null {
+  if (value.type === 'started') return { type: 'started', route, sourceId };
+  if (value.type === 'heard') return typeof value.text === 'string' && value.text.length <= 32_000 ? { type: 'heard', route, sourceId, text: value.text } : null;
+  if (value.type !== 'speech' || !filled(value.actionId)) return null;
+  const status = speechStatus(value.status);
+  return status === null ? null : { type: 'speech', route, sourceId, actionId: value.actionId, status };
+}
+
+export function callNotice(value: unknown): CallNotice | null {
+  if (!isRecord(value)) return null;
+  const route = callRoute(value.route);
+  if (route === null) return null;
+  if (value.type === 'ended') return { type: 'ended', route };
+  return filled(value.sourceId) ? sourcedNotice(value, route, value.sourceId) : null;
+}
+
+export const sameCall = (a: CallRoute, b: CallRoute): boolean =>
+  a.agentId === b.agentId && a.line === b.line && a.from === b.from && a.callId === b.callId && a.generation === b.generation;

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/runner-activity.ts

@@ -74,6 +74,17 @@ export interface RunnerFailure extends RunnerEvent {
   code: RunnerFailureCode;
 }
 
+export interface RunnerInput {
+  id: string;
+  kind: 'chat' | 'call' | 'note';
+  state: 'accepted' | 'consumed' | 'output' | 'completed' | 'cancelled';
+  acceptedAt: number;
+  dispatchedAt: number | null;
+  consumedAt: number | null;
+  firstOutputAt: number | null;
+  completedAt: number | null;
+}
+
 export interface RunnerActivity {
   pid: number;
   procStart?: string;
@@ -84,6 +95,9 @@ export interface RunnerActivity {
   sessionId: string | null;
   updatedAt: number;
   pending: number;
+  queueOldestAt?: number | null;
+  inputs?: RunnerInput[];
+  callState?: 'started' | 'ended' | 'accepted' | 'queued' | 'speaking' | 'completed' | 'interrupted' | 'failed';
   workers: number;
   approvals: number;
   tools: string[];
@@ -160,6 +174,28 @@ function failureFields(raw: Record<string, unknown>): Pick<RunnerActivity, 'last
   };
 }
 
+function input(raw: unknown): RunnerInput | null {
+  if (!isRecord(raw) || sessionId(raw.id) === null) return null;
+  const kind = (['chat', 'call', 'note'] as const).find((value) => value === raw.kind);
+  const state = (['accepted', 'consumed', 'output', 'completed', 'cancelled'] as const).find((value) => value === raw.state);
+  if (kind === undefined || state === undefined) return null;
+  return {
+    id: String(raw.id), kind, state, acceptedAt: count(raw.acceptedAt),
+    dispatchedAt: count(raw.dispatchedAt) || null, consumedAt: count(raw.consumedAt) || null,
+    firstOutputAt: count(raw.firstOutputAt) || null, completedAt: count(raw.completedAt) || null,
+  };
+}
+
+function inputFields(raw: Record<string, unknown>): Pick<RunnerActivity, 'inputs' | 'queueOldestAt' | 'callState'> {
+  const states = ['started', 'ended', 'accepted', 'queued', 'speaking', 'completed', 'interrupted', 'failed'] as const;
+  const callState = states.find((state) => state === raw.callState);
+  return {
+    ...(raw.inputs === undefined ? {} : { inputs: list(raw.inputs, input, 40) }),
+    ...(raw.queueOldestAt === undefined ? {} : { queueOldestAt: count(raw.queueOldestAt) || null }),
+    ...(callState === undefined ? {} : { callState }),
+  };
+}
+
 export function parseRunnerActivity(raw: unknown): RunnerActivity | null {
   if (!isRecord(raw) || raw.runner !== 'sdk' || !phase(raw.phase) || count(raw.pid) === 0 || count(raw.updatedAt) === 0) return null;
   return {
@@ -168,6 +204,6 @@ export function parseRunnerActivity(raw: unknown): RunnerActivity | null {
     pending: count(raw.pending), workers: count(raw.workers), approvals: count(raw.approvals),
     tools: list(raw.tools, name, 20), activeTools: list(raw.activeTools, tool, 20),
     tasks: list(raw.tasks, task, 30), events: list(raw.events, event, 40),
-    ...failureFields(raw),
+    ...failureFields(raw), ...inputFields(raw),
   };
 }

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.264",
+  "version": "0.1.0-beta.265",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "@modelcontextprotocol/sdk": "^1.29.0",

package/runtime/sdk-runner/src/activity.ts

@@ -3,7 +3,7 @@ import { readFileSync } from 'node:fs';
 import type { SDKMessage } from '@anthropic-ai/claude-agent-sdk';
 import { isRecord } from '@metro-labs/core/is-record';
 import { log } from '@metro-labs/core/log';
-import { runnerFailureSummary, type RunnerActivity, type RunnerEvent, type RunnerEventKind, type RunnerFailure, type RunnerFailureCode, type RunnerPhase, type RunnerTool } from '@metro-labs/core/runner-activity';
+import { runnerFailureSummary, type RunnerActivity, type RunnerEvent, type RunnerEventKind, type RunnerFailure, type RunnerFailureCode, type RunnerInput, type RunnerPhase, type RunnerTool } from '@metro-labs/core/runner-activity';
 import { writeAtomic } from '@metro-labs/core/secure-fs';
 import { ActivityTasks, activityName } from './activity-tasks.js';
 import type { ApprovalAsk } from './approvals.js';
@@ -91,12 +91,24 @@ export class Activity {
     return {
       ...s, tools: [...s.tools], activeTools: s.activeTools.map((tool) => ({ ...tool })),
       tasks: s.tasks.map((task) => ({ ...task })), events: s.events.map((event) => ({ ...event })),
+      ...(s.inputs === undefined ? {} : { inputs: s.inputs.map((input) => ({ ...input })) }),
       activeFailure: s.activeFailure ? { ...s.activeFailure } : null, lastFailure: s.lastFailure ? { ...s.lastFailure } : null,
     };
   }
 
-  pending(count: number): void {
+  pending(count: number, oldest?: number | null): void {
     this.state.pending = count;
+    if (oldest !== undefined) this.state.queueOldestAt = oldest;
+    this.update();
+  }
+
+  input(input: RunnerInput): void {
+    this.state.inputs = [input, ...(this.state.inputs ?? []).filter((entry) => entry.id !== input.id)].slice(0, MAX_EVENTS);
+    this.update();
+  }
+
+  call(state: NonNullable<RunnerActivity['callState']>): void {
+    this.state.callState = state;
     this.update();
   }
 

package/runtime/sdk-runner/src/app.ts

@@ -7,7 +7,6 @@ import { MetroLink } from './link.js';
 import { Runner, runnerOptions } from './runner.js';
 import { SessionStore } from './session-store.js';
 import { claimRunner } from './singleton.js';
-import type { SpeechSink } from './speech.js';
 import { metroTools, type MetroTools } from './tool-proxy.js';
 
 export interface RunningAgent {
@@ -18,7 +17,6 @@ export interface RunningAgent {
 }
 
 export interface AppHooks {
-  speech: SpeechSink;
   lost(reason: string): void;
   observe?: (message: SDKMessage) => void;
   env?: NodeJS.ProcessEnv;
@@ -29,9 +27,11 @@ export interface AppHooks {
 async function connected(cfg: RunnerConfig, hooks: AppHooks, release: () => Promise<void>): Promise<RunningAgent> {
   const store = new SessionStore(cfg.statePath, cfg.claudeDir, cfg.cwd);
   let tools: MetroTools | null = null;
-  const runner = new Runner({ store, sink: hooks.speech, readOnly: (tool) => tools?.readOnly(tool) ?? false, ...hooks });
+  const runner = new Runner({ store, readOnly: (tool) => tools?.readOnly(tool) ?? false, ...hooks });
   const link = await MetroLink.open(cfg.mcpUrl, cfg.key, {
     channel: (event) => { runner.chat(event); },
+    call: (notice) => { runner.calls.notice(notice); },
+    callState: (state) => { runner.calls.reconcile(state.route); },
     toolsChanged: () => { tools?.changed(); },
     model: (model) => {
       log.info({ model }, 'sdk-runner: the Model page picked a model');
@@ -54,7 +54,8 @@ async function connected(cfg: RunnerConfig, hooks: AppHooks, release: () => Prom
     tools = metroTools(link);
     const resume = store.resumable();
     log.info({ resume, model: cfg.model, mode: cfg.permissionMode }, 'sdk-runner: starting the Agent SDK session');
-    runner.start(runnerOptions(cfg, tools, approvalsThrough(link, (id, ask) => { hooks.activity?.approval(id, ask); }), resume, hooks.env));
+    const approvals = approvalsThrough(link, (id, ask) => { hooks.activity?.approval(id, ask); }, (tool, input) => runner.calls.approval(tool, input));
+    runner.start(runnerOptions(cfg, tools, approvals, resume, hooks.env));
     return { runner, link, done: runner.run(hooks.observe), stop };
   } catch (err) {
     runner.close(false);

package/runtime/sdk-runner/src/approvals.ts

@@ -1,4 +1,5 @@
 import { approvalId } from '@metro-labs/core/ids';
+import type { CallSource } from '@metro-labs/core/call';
 import type { CanUseTool } from '@anthropic-ai/claude-agent-sdk';
 import { log } from '@metro-labs/core/log';
 import type { Asker } from './link.js';
@@ -8,21 +9,29 @@ const DENIED = 'The owner did not approve this.';
 export interface ApprovalAsk { tool: string; worker: string | null }
 export type ApprovalWatch = (id: string, ask: ApprovalAsk | null) => void;
 
-export function approvalsThrough(asker: Asker, waiting: ApprovalWatch = () => undefined): CanUseTool {
+export interface ApprovalBinding { call: CallSource; signal: AbortSignal }
+export type BindApproval = (tool: string, input: Record<string, unknown>) => ApprovalBinding | null | undefined;
+
+export function approvalsThrough(asker: Asker, waiting: ApprovalWatch = () => undefined, bind: BindApproval = () => undefined): CanUseTool {
   return async (tool, input, options) => {
+    const binding = bind(tool, input);
+    if (binding === null) return { behavior: 'deny', message: 'This speech target is no longer authorized for the active call.' };
+    const signal = binding === undefined ? options.signal : AbortSignal.any([options.signal, binding.signal]);
     const id = approvalId();
-    log.info({ tool, id, worker: options.agentID ?? null }, 'sdk-runner: a tool waits for the owner’s approval');
-    waiting(id, { tool, worker: options.agentID ?? null });
+    const worker = options.agentID ?? null;
+    log.info({ tool, id, worker }, 'sdk-runner: a tool waits for the owner’s approval');
+    waiting(id, { tool, worker });
     const behavior = await asker.ask(
       {
         request_id: id,
         tool_name: tool,
         description: options.description ?? options.title ?? options.decisionReason ?? '',
         input_preview: JSON.stringify(input),
+        ...(binding === undefined ? {} : { call: binding.call }),
       },
-      options.signal,
+      signal,
     ).finally(() => { waiting(id, null); });
     log.info({ tool, id, behavior }, 'sdk-runner: the owner answered');
-    return behavior === 'allow' ? { behavior, updatedInput: input } : { behavior, message: DENIED };
+    return behavior === 'allow' && !signal.aborted ? { behavior, updatedInput: input } : { behavior: 'deny', message: DENIED };
   };
 }

package/runtime/sdk-runner/src/calls.ts

@@ -0,0 +1,133 @@
+import { sameCall, speechTarget, type CallNotice, type CallRoute, type CallSource } from '@metro-labs/core/call';
+import { log } from '@metro-labs/core/log';
+import type { Activity } from './activity.js';
+import type { ApprovalBinding } from './approvals.js';
+import type { ChannelEvent } from './channel-text.js';
+import type { Inbox } from './inbox.js';
+import { callEnded, callStarted, callWords, speechFailed } from './rules.js';
+
+const GENERATIONS_MAX = 512;
+const SOURCES_MAX = 2_048;
+interface ActiveCall {
+  route: CallRoute;
+  sources: Set<string>;
+  failures: Set<string>;
+  inputs: string[];
+  controller: AbortController;
+}
+
+const routeKey = (route: CallRoute): string => JSON.stringify([route.agentId, route.line, route.from, route.callId, route.generation]);
+
+export class RunnerCalls {
+  private active: ActiveCall | null = null;
+  private readonly seen = new Set<string>();
+
+  constructor(private readonly inbox: Inbox, private readonly activity?: Activity) {}
+
+  get live(): boolean { return this.active !== null; }
+
+  notice(notice: CallNotice): void {
+    if (notice.type === 'started') this.start(notice);
+    else if (this.active !== null && sameCall(notice.route, this.active.route)) {
+      if (notice.type === 'ended') this.end();
+      else if (notice.type === 'heard') this.heard(notice);
+      else this.speech(notice);
+    }
+  }
+
+  reconcile(route: CallRoute | null): void {
+    if (route !== null && this.active !== null && sameCall(route, this.active.route)) return;
+    this.end();
+    if (route !== null) this.activate(route);
+  }
+
+  chat(event: ChannelEvent): void {
+    const active = this.active;
+    if (active === null) return;
+    const { meta } = event;
+    if (meta.line !== active.route.line || meta.from !== active.route.from || meta.call_id !== active.route.callId || meta.call_generation !== active.route.generation) return;
+    if (typeof meta.call_source_id !== 'string' || meta.call_source_id.length === 0 || meta.call_source_id.length > 2048) return;
+    if (active.sources.size < SOURCES_MAX) active.sources.add(meta.call_source_id);
+  }
+
+  approval(tool: string, input: Record<string, unknown>): ApprovalBinding | null | undefined {
+    if (tool !== 'mcp__metro__send' || input.speech === undefined) return undefined;
+    const target = speechTarget(input.speech);
+    const active = this.active;
+    if (active === null || target === null || input.line !== active.route.line || target.callId !== active.route.callId || target.generation !== active.route.generation || !active.sources.has(target.sourceId)) return null;
+    return { call: { route: active.route, sourceId: target.sourceId }, signal: active.controller.signal };
+  }
+
+  close(): void {
+    this.active?.controller.abort();
+    this.active = null;
+  }
+
+  private activate(route: CallRoute): boolean {
+    const key = routeKey(route);
+    if (this.seen.has(key)) return false;
+    this.seen.add(key);
+    if (this.seen.size > GENERATIONS_MAX) {
+      const oldest = this.seen.values().next().value;
+      if (oldest !== undefined) this.seen.delete(oldest);
+    }
+    this.end();
+    this.active = { route, sources: new Set(), failures: new Set(), inputs: [], controller: new AbortController() };
+    this.activity?.call('started');
+    return true;
+  }
+
+  private start(notice: Extract<CallNotice, { type: 'started' }>): void {
+    if (this.activate(notice.route)) this.push(notice, callStarted(notice));
+  }
+
+  private heard(notice: Extract<CallNotice, { type: 'heard' }>): void {
+    if (notice.text.trim() === '') return;
+    this.push(notice, callWords(notice, notice.text));
+  }
+
+  private speech(notice: Extract<CallNotice, { type: 'speech' }>): void {
+    this.activity?.call(notice.status === 'started' ? 'speaking' : notice.status);
+    const active = this.active;
+    if (notice.status !== 'failed' || active === null || !active.sources.has(notice.sourceId)) return;
+    if (active.failures.has(notice.actionId) || active.failures.size >= SOURCES_MAX) return;
+    active.failures.add(notice.actionId);
+    try {
+      this.inbox.push('note', speechFailed(active.route));
+    } catch {
+      log.warn('sdk-runner: speech failure context could not be queued');
+    }
+  }
+
+  private push(source: CallSource, text: string): void {
+    const active = this.active;
+    if (active === null || active.sources.has(source.sourceId) || active.sources.size >= SOURCES_MAX) return;
+    active.sources.add(source.sourceId);
+    this.enqueue(text);
+  }
+
+  private enqueue(text: string): void {
+    const active = this.active;
+    if (active === null) return;
+    try {
+      active.inputs.push(this.inbox.push('call', text));
+    } catch {
+      this.activity?.call('failed');
+      log.warn('sdk-runner: call input queue refused a message');
+    }
+  }
+
+  private end(): void {
+    const active = this.active;
+    if (active === null) return;
+    this.active = null;
+    active.controller.abort();
+    this.inbox.cancel(active.inputs);
+    this.activity?.call('ended');
+    try {
+      this.inbox.push('note', callEnded(active.route));
+    } catch {
+      log.warn('sdk-runner: call end context could not be queued');
+    }
+  }
+}