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

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/stations/train-boot.ts

@@ -1,4 +1,4 @@
-import { errMsg } from '../log.js';
+import { errMsg, logFatalSync } from '../log.js';
 import { readCalls } from '../protocol.js';
 import { TrainError } from '../train-error.js';
 import type { CallMsg } from './station-runtime.js';
@@ -18,12 +18,33 @@ export interface ClientTrain<A extends { id: string }, C> {
   loadAccounts: () => A[];
   createClient: (account: A) => C;
   startInbound: (client: C) => Promise<void>;
+  disconnectClient?: (client: C) => Promise<void>;
   makeHandleCall: (clientFor: (accountId: string) => C) => (msg: CallMsg) => Promise<void>;
 }
 
 export function runClientTrain<A extends { id: string }, C>(train: ClientTrain<A, C>): void {
   const clients = new Map<string, C>();
+  let stopping = false;
+  if (train.disconnectClient) {
+    const disconnect = train.disconnectClient;
+    const shutdown = (): void => {
+      if (stopping) return;
+      stopping = true;
+      process.stdin.pause();
+      Promise.allSettled([...clients.values()].map(async (client) => { await disconnect(client); })).then((results) => {
+        const errors = results.flatMap((result) => result.status === 'rejected' ? [errMsg(result.reason)] : []);
+        if (errors.length) logFatalSync({ station: train.station, errors }, 'train: shutdown failed');
+        process.exit(errors.length ? 1 : 0);
+      }).catch((err: unknown) => {
+        logFatalSync({ station: train.station, err: errMsg(err) }, 'train: shutdown failed');
+        process.exit(1);
+      });
+    };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+  }
   const clientFor = (accountId: string): C => {
+    if (stopping) throw new TrainError('train_stopping', `${train.station} is shutting down`);
     const known = clients.get(accountId);
     if (known !== undefined) return known;
     const account = train.accounts.get(accountId);

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.263",
+  "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');
+    }
+  }
+}

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

@@ -1,8 +1,11 @@
 import { randomUUID } from 'node:crypto';
 import type { SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { RunnerInput } from '@metro-labs/core/runner-activity';
+import { InputQueue } from './input-queue.js';
+import { InputTiming, type InputWatch } from './input-timing.js';
 
 export type Uuid = ReturnType<typeof randomUUID>;
-export type InputKind = 'chat' | 'call' | 'note';
+export type InputKind = RunnerInput['kind'];
 export type Priority = 'now' | 'next' | 'later';
 
 export interface Unanswered {
@@ -12,32 +15,49 @@ export interface Unanswered {
   state?: 'queued' | 'started';
 }
 
+interface InboxHooks {
+  ready?(): boolean;
+  dispatch?(): void;
+  queue?(count: number, oldest: number | null): void;
+  input?: InputWatch;
+}
+
 const KINDS_MAX = 2_000;
 const LEDGER_MAX = 100;
 const LEDGER_AGE_MS = 6 * 60 * 60_000;
 
 export class Inbox implements AsyncIterable<SDKUserMessage> {
-  private readonly queue: SDKUserMessage[] = [];
+  private readonly queue = new InputQueue();
   private readonly kinds = new Map<string, InputKind>();
   private readonly ledger = new Map<string, Unanswered>();
+  private readonly timing: InputTiming;
   private wake: (() => void) | null = null;
   private closed = false;
   private restoring = false;
 
-  constructor(private readonly changed: (unanswered: Unanswered[]) => void = () => undefined) {}
+  constructor(private readonly changed: (unanswered: Unanswered[]) => void = () => undefined, private readonly hooks: InboxHooks = {}) {
+    this.timing = new InputTiming(hooks.input ?? (() => undefined));
+  }
 
-  push(kind: InputKind, text: string, priority?: Priority, uuid: Uuid = randomUUID(), at = Date.now()): Uuid {
-    this.mark(uuid, kind);
+  get pending(): number { return this.queue.size; }
+
+  compact(): Uuid {
+    const uuid = this.push('note', '/compact');
+    this.queue.prefer(uuid);
+    return uuid;
+  }
+
+  push(kind: InputKind, text: string, _priority?: Priority, uuid: Uuid = randomUUID(), at = Date.now()): Uuid {
+    if (this.closed) throw new Error('The SDK input queue is closed.');
+    this.queue.check(kind, text);
     if (kind === 'chat') this.remember(uuid, text, at);
-    this.queue.push({
-      type: 'user',
-      message: { role: 'user', content: text },
-      parent_tool_use_id: null,
-      uuid,
-      origin: { kind: 'channel', server: 'metro' },
-      ...(priority === undefined ? {} : { priority }),
-    });
-    this.wake?.();
+    this.mark(uuid, kind);
+    this.queue.push(kind, {
+      type: 'user', message: { role: 'user', content: text }, parent_tool_use_id: null,
+      uuid, origin: { kind: 'channel', server: 'metro' },
+    }, text, at);
+    this.timing.accept(uuid, kind, at);
+    this.notify();
     return uuid;
   }
 
@@ -48,9 +68,7 @@ export class Inbox implements AsyncIterable<SDKUserMessage> {
     if (oldest !== undefined) this.kinds.delete(oldest);
   }
 
-  kindOf(uuid: string): InputKind | undefined {
-    return this.kinds.get(uuid);
-  }
+  kindOf(uuid: string): InputKind | undefined { return this.kinds.get(uuid); }
 
   started(uuids: readonly string[]): void {
     let changed = false;
@@ -61,12 +79,24 @@ export class Inbox implements AsyncIterable<SDKUserMessage> {
       changed = true;
     }
     if (changed) this.changed(this.unanswered());
+    this.timing.consume(uuids);
   }
 
+  output(): void { this.timing.output(); }
+  boundary(): void { this.timing.boundary(); }
+
   finished(uuids = this.startedUuids()): void {
     let changed = false;
     for (const uuid of uuids) changed = this.ledger.delete(uuid) || changed;
     if (changed) this.changed(this.unanswered());
+    this.timing.finish(uuids);
+  }
+
+  cancel(uuids: readonly string[]): void {
+    const ephemeral = uuids.filter((uuid) => this.kindOf(uuid) !== 'chat');
+    this.queue.cancel(new Set(ephemeral));
+    this.timing.finish(ephemeral, true);
+    this.notify();
   }
 
   startedUuids(): string[] {
@@ -82,16 +112,22 @@ export class Inbox implements AsyncIterable<SDKUserMessage> {
     this.wake?.();
   }
 
+  notify(): void {
+    this.hooks.queue?.(this.queue.size, this.queue.oldest);
+    this.wake?.();
+  }
+
   async *[Symbol.asyncIterator](): AsyncIterator<SDKUserMessage> {
     while (!this.closed) {
-      const next = this.queue.shift();
+      const next = (this.hooks.ready?.() ?? true) ? this.queue.take() : undefined;
       if (next !== undefined) {
+        this.hooks.dispatch?.();
+        if (next.uuid !== undefined) this.timing.dispatch(next.uuid);
+        this.notify();
         yield next;
         continue;
       }
-      await new Promise<void>((resolve) => {
-        this.wake = resolve;
-      });
+      await new Promise<void>((resolve) => { this.wake = resolve; });
       this.wake = null;
     }
   }
@@ -108,12 +144,8 @@ export class Inbox implements AsyncIterable<SDKUserMessage> {
   }
 
   private remember(uuid: Uuid, text: string, at: number): void {
+    if (!this.ledger.has(uuid) && this.ledger.size >= LEDGER_MAX) throw new Error('The SDK input queue is full. Wait for queued work to finish before retrying.');
     this.ledger.set(uuid, { text, at, uuid, state: 'queued' });
-    while (this.ledger.size > LEDGER_MAX) {
-      const oldest = [...this.ledger].find(([, entry]) => entry.state !== 'started')?.[0];
-      if (oldest === undefined) break;
-      this.ledger.delete(oldest);
-    }
     if (!this.restoring) this.changed(this.unanswered());
   }
 }

package/runtime/sdk-runner/src/input-queue.ts

@@ -0,0 +1,70 @@
+import type { SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { RunnerInput } from '@metro-labs/core/runner-activity';
+
+type InputKind = RunnerInput['kind'];
+
+const LANES: readonly InputKind[] = ['chat', 'call', 'note'];
+const CAPS: Record<InputKind, number> = { chat: 100, call: 32, note: 16 };
+const BYTES_MAX = 4 * 1024 * 1024;
+const INPUT_MAX = 256 * 1024;
+
+interface Queued {
+  kind: InputKind;
+  message: SDKUserMessage;
+  bytes: number;
+  at: number;
+}
+
+export class InputQueue {
+  private readonly items: Queued[] = [];
+  private bytes = 0;
+  private lane = 0;
+  private first: string | null = null;
+
+  prefer(uuid: string): void { this.first = uuid; }
+
+  get size(): number { return this.items.length; }
+  get oldest(): number | null { return this.items.reduce<number | null>((at, item) => at === null ? item.at : Math.min(at, item.at), null); }
+
+  check(kind: InputKind, text: string): void {
+    const bytes = Buffer.byteLength(text);
+    if (bytes > INPUT_MAX || this.bytes + bytes > BYTES_MAX || this.items.filter((item) => item.kind === kind).length >= CAPS[kind]) {
+      throw new Error('The SDK input queue is full. Wait for queued work to finish before retrying.');
+    }
+  }
+
+  push(kind: InputKind, message: SDKUserMessage, text: string, at: number): void {
+    const bytes = Buffer.byteLength(text);
+    this.items.push({ kind, message, bytes, at });
+    this.bytes += bytes;
+  }
+
+  take(): SDKUserMessage | undefined {
+    if (this.first !== null) {
+      const index = this.items.findIndex((item) => item.message.uuid === this.first);
+      this.first = null;
+      if (index >= 0) return this.remove(index)?.message;
+    }
+    for (let i = 0; i < LANES.length; i += 1) {
+      const lane = (this.lane + i) % LANES.length;
+      const index = this.items.findIndex((item) => item.kind === LANES[lane]);
+      if (index < 0) continue;
+      this.lane = (lane + 1) % LANES.length;
+      return this.remove(index)?.message;
+    }
+    return undefined;
+  }
+
+  cancel(uuids: ReadonlySet<string>): void {
+    for (let index = this.items.length - 1; index >= 0; index -= 1) {
+      const uuid = this.items[index]?.message.uuid;
+      if (uuid !== undefined && uuids.has(uuid)) this.remove(index);
+    }
+  }
+
+  private remove(index: number): Queued | undefined {
+    const [item] = this.items.splice(index, 1);
+    if (item !== undefined) this.bytes -= item.bytes;
+    return item;
+  }
+}

package/runtime/sdk-runner/src/input-timing.ts

@@ -0,0 +1,68 @@
+import type { RunnerInput } from '@metro-labs/core/runner-activity';
+import { log } from '@metro-labs/core/log';
+
+export type InputWatch = (input: RunnerInput) => void;
+
+export class InputTiming {
+  private readonly inputs = new Map<string, RunnerInput>();
+  private readonly active = new Set<string>();
+
+  constructor(private readonly changed: InputWatch) {}
+
+  accept(id: string, kind: RunnerInput['kind'], at: number): void {
+    const input: RunnerInput = { id, kind, state: 'accepted', acceptedAt: at, dispatchedAt: null, consumedAt: null, firstOutputAt: null, completedAt: null };
+    this.inputs.set(id, input);
+    if (this.inputs.size > 2_000) {
+      const oldest = this.inputs.keys().next().value;
+      if (oldest !== undefined) { this.inputs.delete(oldest); this.active.delete(oldest); }
+    }
+    this.note(input);
+  }
+
+  dispatch(id: string): void {
+    const input = this.inputs.get(id);
+    if (input === undefined) return;
+    input.dispatchedAt = Date.now();
+    this.note(input);
+  }
+
+  consume(uuids: readonly string[]): void {
+    for (const id of uuids) {
+      const input = this.inputs.get(id);
+      if (input === undefined || input.consumedAt !== null) continue;
+      input.consumedAt = Date.now();
+      input.state = 'consumed';
+      this.active.add(id);
+      this.note(input);
+    }
+  }
+
+  output(): void {
+    for (const id of this.active) {
+      const input = this.inputs.get(id);
+      if (input === undefined || input.firstOutputAt !== null) continue;
+      input.firstOutputAt = Date.now();
+      input.state = 'output';
+      this.note(input);
+    }
+  }
+
+  finish(uuids: readonly string[], cancelled = false): void {
+    for (const id of uuids) {
+      const input = this.inputs.get(id);
+      if (input === undefined) continue;
+      input.completedAt = Date.now();
+      input.state = cancelled ? 'cancelled' : 'completed';
+      this.inputs.delete(id);
+      this.active.delete(id);
+      this.note(input);
+    }
+  }
+
+  boundary(): void { this.active.clear(); }
+
+  private note(input: RunnerInput): void {
+    this.changed({ ...input });
+    log.info({ input: input.id, kind: input.kind, state: input.state, queueAgeMs: (input.consumedAt ?? Date.now()) - input.acceptedAt }, 'sdk-runner: input lifecycle');
+  }
+}

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

@@ -3,6 +3,7 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 import { CallToolResultSchema, type CallToolRequest, type CallToolResult, type ListToolsResult, type Notification } from '@modelcontextprotocol/sdk/types.js';
 import { errMsg, log } from '@metro-labs/core/log';
 import { isRecord } from '@metro-labs/core/is-record';
+import { CALL_NOTICE, CALL_STATE, callNotice, callState, type CallNotice, type CallSource, type CallState } from '@metro-labs/core/call';
 import { channelEvent, type ChannelEvent } from './channel-text.js';
 
 const CHANNEL = 'notifications/claude/channel';
@@ -23,10 +24,13 @@ export interface PermissionAsk {
   tool_name: string;
   description: string;
   input_preview: string;
+  call?: CallSource;
 }
 
 export interface LinkEvents {
   channel(event: ChannelEvent): void;
+  call?(notice: CallNotice): void;
+  callState?(state: CallState): void;
   toolsChanged(): void;
   model(model: string | null): void;
   lost(reason: string): void;
@@ -81,14 +85,19 @@ export class MetroLink implements Asker {
   ask(ask: PermissionAsk, signal: AbortSignal): Promise<Behavior> {
     if (signal.aborted) return Promise.resolve('deny');
     return new Promise((resolve) => {
+      const abort = (): void => {
+        settle('deny');
+        this.client.notification({ method: 'notifications/metro/permission_cancel', params: { request_id: ask.request_id } }).catch(() => {
+          log.warn('sdk-runner: could not cancel a pending approval with metro');
+        });
+      };
       const settle = (behavior: Behavior): void => {
-        this.waiting.delete(ask.request_id);
+        signal.removeEventListener('abort', abort);
+        if (!this.waiting.delete(ask.request_id)) return;
         resolve(behavior);
       };
       this.waiting.set(ask.request_id, settle);
-      signal.addEventListener('abort', () => {
-        settle('deny');
-      }, { once: true });
+      signal.addEventListener('abort', abort, { once: true });
       this.client.notification({ method: ASK, params: { ...ask } }).catch((err: unknown) => {
         log.warn({ err: errMsg(err), id: ask.request_id }, 'sdk-runner: could not hand an approval to metro');
         settle('deny');
@@ -106,6 +115,10 @@ export class MetroLink implements Asker {
     if (notification.method === CHANNEL) {
       const event = channelEvent(params);
       if (event !== null) this.events.channel(event);
+    } else if (notification.method === CALL_NOTICE) {
+      this.callNotified(params);
+    } else if (notification.method === CALL_STATE) {
+      this.reconciled(params);
     } else if (notification.method === ANSWER) {
       this.answered(params);
     } else if (notification.method === TOOLS_CHANGED) {
@@ -115,6 +128,16 @@ export class MetroLink implements Asker {
     }
   }
 
+  private callNotified(params: Record<string, unknown>): void {
+    const notice = callNotice(params);
+    if (notice !== null) this.events.call?.(notice);
+  }
+
+  private reconciled(params: Record<string, unknown>): void {
+    const state = callState(params);
+    if (state !== null) this.events.callState?.(state);
+  }
+
   private answered(params: Record<string, unknown>): void {
     const id = typeof params.request_id === 'string' ? params.request_id : '';
     this.waiting.get(id)?.(params.behavior === 'allow' ? 'allow' : 'deny');

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

@@ -23,10 +23,6 @@ try {
   activity = new Activity(join(dirname(cfg.statePath), 'agent-status.json'));
   agent = await startAgent(cfg, {
     activity,
-    speech: {
-      say: (text) => { log.debug({ chars: text.length }, 'sdk-runner: speech'); },
-      done: () => { log.debug('sdk-runner: speech done'); },
-    },
     lost: () => {
       activity?.fail('The SDK lost its Metro connection. The session will restart.');
       exitWith(1)();