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

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

@@ -17,6 +17,7 @@ import {
 import { errMsg } from '@metro-labs/core/log';
 import { channelLog, type McpSession } from './session.js';
 import { SessionSlot } from './session-slot.js';
+import { connectCallBridge } from './call-bridge.js';
 
 const isInitialize = (b: unknown): boolean =>
   !!b &&
@@ -116,6 +117,7 @@ export async function createMetroMcp(options: { liveEvents?: boolean } = {}): Pr
   const slot = new SessionSlot(options.liveEvents);
   const voiceSlot = new SessionSlot(false, 'voice');
   activeSlots = [slot, voiceSlot];
+  connectCallBridge(() => slot.current);
 
   const httpHandler = async (
     req: IncomingMessage,

package/runtime/node_modules/@metro-labs/daemon/src/mcp/permission-prompt.ts

@@ -45,13 +45,14 @@ function argText(value: unknown): string | undefined {
 
 function fieldText(key: string, value: unknown): string | undefined {
   if (key === 'attachments' && Array.isArray(value)) return `${String(value.length)} file(s)`;
-  return key === 'frame' || key === 'wallet' ? argText(value) : valueText(value);
+  return key === 'frame' || key === 'wallet' || key === 'speech' ? argText(value) : valueText(value);
 }
 
 function metroLines(tool: string, input: Record<string, unknown>): string[] {
   const lines = [`Approval needed: ${tool}`];
   const channel = channelOf(input);
   if (channel !== undefined) lines.push(`Channel: ${channel}`);
+  if (tool === 'send' && input.speech !== undefined) lines.push('Delivery: voice call only, no chat post');
   const keys = [...LEAD, ...Object.keys(input).filter((k) => !LEAD.includes(k))];
   for (const key of keys) {
     if (PLACE.has(key)) continue;

package/runtime/node_modules/@metro-labs/daemon/src/mcp/permission-relay.ts

@@ -1,10 +1,11 @@
 import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { z } from 'zod';
 import type { InboundRelay } from '../channels/inbound.js';
-import { holdPrompt, type Behavior } from '../approvals/pending.js';
+import { cancelPrompt, holdPrompt, type Behavior } from '../approvals/pending.js';
 import { approversForLine, lineReceives } from '../agents/map.js';
 import { metroCall } from './ctx.js';
 import { promptBody } from './permission-prompt.js';
+import { permissionCall } from './call-permission.js';
 
 const PermissionRequestSchema = z.object({
   method: z.literal('notifications/claude/channel/permission_request'),
@@ -13,6 +14,7 @@ const PermissionRequestSchema = z.object({
     tool_name: z.string(),
     description: z.string(),
     input_preview: z.string(),
+    call: z.unknown().optional(),
   }),
 });
 
@@ -32,12 +34,12 @@ export interface PermissionRelayDeps {
   log: (...a: unknown[]) => void;
 }
 
-function relayLine(deps: PermissionRelayDeps, requestId: string): string | undefined {
+function relayLine(deps: PermissionRelayDeps, requestId: string, callLine?: string): string | undefined {
   if (!deps.live()) {
     deps.log('permission_request: live events are off, so no chat answer can arrive; held for the page only', requestId);
     return undefined;
   }
-  const line = deps.relay.knownLine;
+  const line = callLine ?? deps.relay.knownLine;
   if (!line) {
     deps.log('permission_request: no known line, held for the page only', requestId);
     return undefined;
@@ -59,12 +61,20 @@ function relayLine(deps: PermissionRelayDeps, requestId: string): string | undef
 
 export function registerPermissionRelay(deps: PermissionRelayDeps): void {
   const { mcp, log } = deps;
+  mcp.setNotificationHandler(z.object({ method: z.literal('notifications/metro/permission_cancel'), params: z.object({ request_id: z.string() }) }), (notice) => {
+    cancelPrompt(notice.params.request_id, mcp);
+  });
   const answer = (requestId: string) => async (behavior: Behavior): Promise<void> => {
     await mcp.notification({ method: 'notifications/claude/channel/permission', params: { request_id: requestId, behavior } });
   };
   mcp.setNotificationHandler(PermissionRequestSchema as never, async (n: PermissionRequest) => {
     const { params } = n;
-    const line = relayLine(deps, params.request_id);
+    const call = permissionCall(params, deps.inScope);
+    if (call === null) {
+      await answer(params.request_id)('deny');
+      return;
+    }
+    const line = relayLine(deps, params.request_id, call?.route.line);
     holdPrompt(
       {
         requestId: params.request_id,
@@ -73,6 +83,7 @@ export function registerPermissionRelay(deps: PermissionRelayDeps): void {
         preview: params.input_preview,
         line,
         at: Date.now(),
+        ...(call === undefined ? {} : { call }),
       },
       mcp,
       answer(params.request_id),

package/runtime/node_modules/@metro-labs/daemon/src/mcp/policy-gate.ts

@@ -13,9 +13,9 @@ type ChannelTarget = Extract<PolicyTarget, { kind: 'channel' }>;
 
 export const UNGATED = new Set<string>(['list_accounts', 'create_upload']);
 
-function fromLine(line: string, override: string | undefined): ChannelTarget[] {
+function fromLine(line: string, override = ''): ChannelTarget[] {
   const acct = accountFromLine(line);
-  return acct === undefined ? [] : [{ kind: 'channel', station: acct.station, account: override ?? acct.accountId }];
+  return acct === undefined ? [] : [{ kind: 'channel', station: acct.station, account: override || acct.accountId }];
 }
 
 function channelTargets(name: string, a: Record<string, unknown>): ChannelTarget[] {
@@ -26,7 +26,7 @@ function channelTargets(name: string, a: Record<string, unknown>): ChannelTarget
   }
   const account = str(a.account);
   const line = str(a.line);
-  if (line) return fromLine(line, account || undefined);
+  if (line) return fromLine(line, name === 'list_members' ? undefined : account);
   const station = stationForTool(name, a) ?? (account ? stationOfAccount(account) : undefined);
   if (station === undefined) return [];
   if (account) return [{ kind: 'channel', station, account }];

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

@@ -12,6 +12,8 @@ import { BoundedEventStore } from './event-store.js';
 import { registerPermissionRelay } from './permission-relay.js';
 import { registerToolHandlers, toolSchemaSignature } from './tool-dispatch.js';
 import { web, type RawGetSink } from './raw-get-stream.js';
+import { sharedCalls } from '../voice/shared.js';
+import { CALL_STATE } from '@metro-labs/core/call';
 
 export const channelLog = (...a: unknown[]): void => {
   console.error('[metro-mcp]', ...a);
@@ -76,9 +78,11 @@ export class McpSession {
   private issuedSchema: string | undefined;
   private announcing = false;
   private readonly onClosed: (session: McpSession) => void;
+  private readonly kind: SessionKind;
 
   private constructor(init: SessionInit) {
     this.id = init.id;
+    this.kind = init.kind ?? 'chat';
     this.scope = init.scope;
     this.live = init.live;
     this.issuedSchema = init.adopted ? undefined : toolSchemaSignature();
@@ -112,6 +116,7 @@ export class McpSession {
       senderAllowed,
       approves,
       answerPermission,
+      callMeta: (event) => voice ? () => ({}) : sharedCalls.bindChat(event, this.scope),
     });
     if (!voice)
       registerPermissionRelay({
@@ -167,7 +172,20 @@ export class McpSession {
 
   bindSink(sink: RawGetSink | undefined): void {
     this.sink = sink;
-    if (sink !== undefined) this.announceToolSchema();
+    if (sink !== undefined) {
+      this.announceCallState();
+      this.announceToolSchema();
+    }
+  }
+
+  private announceCallState(): void {
+    if (this.kind !== 'chat' || !this.streamAttached || this.server.getClientVersion()?.name !== 'metro-sdk-runner') return;
+    const active = sharedCalls.snapshot();
+    const route = active !== null && this.scope.has(active.agentId) && eventInScope(this.scope, active.line) ? active : null;
+    this.server.notification({ method: CALL_STATE, params: { route, ...(route === null ? {} : { meta: { line: route.line } }) } }).catch((err: unknown) => {
+      channelLog('session: call state notification failed', errMsg(err));
+      if (route !== null) sharedCalls.end(route);
+    });
   }
 
   private get schemaNoticeDue(): boolean {
@@ -206,6 +224,7 @@ export class McpSession {
   async close(): Promise<void> {
     if (this.closed) return;
     this.closed = true;
+    if (this.kind === 'chat') sharedCalls.revoke();
     this.onClosed(this);
     forgetPromptsOf(this.server);
     this.dropStream();

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

@@ -0,0 +1,11 @@
+export const speechSchema = {
+  type: 'object',
+  description: 'Speak text only in the exact active Stage call, without posting it in chat. Copy callId, generation and sourceId from its authenticated call input or call_id, call_generation and call_source_id from the requesting channel message. Use only for a call reply or an explicit owner request to speak in that call. Normal chat and worker results stay silent. One action per source; retries do not repeat speech. Accepted or queued is not heard. Completed means audio transport drained, not proof the caller heard it.',
+  properties: {
+    callId: { type: 'string' },
+    generation: { type: 'string' },
+    sourceId: { type: 'string' },
+  },
+  required: ['callId', 'generation', 'sourceId'],
+  additionalProperties: false,
+} as const;

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

@@ -0,0 +1,15 @@
+import { speechTarget } from '@metro-labs/core/call';
+import type { ToolResult } from '@metro-labs/core/stations/types';
+import { sharedCalls } from '../voice/shared.js';
+import { allowedAgents, currentIdentity } from './request-identity.js';
+import { errResult, okJson } from './ctx.js';
+
+export function sendSpeech(line: string, args: Record<string, unknown>): ToolResult {
+  const target = speechTarget(args.speech);
+  if (target === null) return errResult('Call speech needs callId, generation and sourceId from its authenticated source.');
+  if (['reply_to', 'subject', 'attachments', 'frame', 'wallet', 'account'].some((key) => args[key] !== undefined))
+    return errResult('Call speech cannot include chat content, media or an account override. Nothing was sent.');
+  if (typeof args.text !== 'string') return errResult('Call speech needs text.');
+  const receipt = sharedCalls.speak(line, target, args.text, allowedAgents(currentIdentity()));
+  return okJson({ speech: receipt, delivery: 'Audio transport status only. No proof the caller heard it. No chat message was posted.' });
+}

package/runtime/node_modules/@metro-labs/daemon/src/mcp/tool-schemas.ts

@@ -1,5 +1,6 @@
 import type { ToolDef } from './tool-def.js';
 import { attachmentItem, CREATE_UPLOAD_TOOL } from './attachment-schema.js';
+import { speechSchema } from './speech-schema.js';
 
 const lineProp = {
   type: 'string',
@@ -34,7 +35,7 @@ export const COMMON_TOOLS: ToolDef[] = [
     group: 'write',
     description:
       'Send a message (and/or media) to a Metro conversation. Args: line, text?, reply_to?, ' +
-      'subject?, attachments?, frame?, wallet?. The station is derived from the line. Outlook and Gmail: send to ' +
+      'subject?, attachments?, frame?, wallet?, speech?. `speech` speaks text only in an authorized active call, never posts it in chat. The station is derived from the line. Outlook and Gmail: send to ' +
       'metro://<outlook|gmail>/<account>/<email address> to start a new email (subject defaults to the ' +
       'first line of text); the result names the new thread line. Each attachment names EXACTLY ONE ' +
       'source, and the choice matters: `upload` (an `upload_id` from `create_upload`, the ' +
@@ -54,6 +55,7 @@ export const COMMON_TOOLS: ToolDef[] = [
           type: 'string',
           description: 'The message text (optional if sending only media).',
         },
+        speech: speechSchema,
         reply_to: {
           type: 'string',
           description: 'Optional message_id to quote/reply to.',

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

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { log } from '@metro-labs/core/log';
 import { isRecord } from '@metro-labs/core/is-record';
@@ -11,6 +11,7 @@ const INSTALL_TIMEOUT_MS = 15 * 60_000;
 export interface RuntimeManifest {
   core: Record<string, string>;
   stations: Record<string, Record<string, string>>;
+  patchedDependencies?: Record<string, string>;
 }
 
 export interface RuntimeStore {
@@ -30,6 +31,7 @@ export function readManifest(path: string): RuntimeManifest {
   return {
     core: ranges(raw.core),
     stations: Object.fromEntries(Object.entries(stations).map(([name, deps]) => [name, ranges(deps)])),
+    ...(raw.patchedDependencies === undefined ? {} : { patchedDependencies: ranges(raw.patchedDependencies) }),
   };
 }
 
@@ -46,8 +48,21 @@ export function dependenciesFor(manifest: RuntimeManifest, stations: Iterable<st
   return Object.fromEntries(Object.entries(out).sort(([a], [b]) => a.localeCompare(b)));
 }
 
-const packageText = (deps: Record<string, string>): string =>
-  `${JSON.stringify({ name: 'metro-runtime', private: true, dependencies: deps }, null, 2)}\n`;
+function packageText(deps: Record<string, string>, patches: Record<string, string>): string {
+  const patchedDependencies = Object.fromEntries(
+    Object.entries(deps).flatMap(([name, version]) => {
+      const key = `${name}@${version}`;
+      const path = patches[key];
+      return path === undefined ? [] : [[key, path]];
+    }),
+  );
+  return `${JSON.stringify({
+    name: 'metro-runtime',
+    private: true,
+    dependencies: deps,
+    ...(Object.keys(patchedDependencies).length === 0 ? {} : { patchedDependencies }),
+  }, null, 2)}\n`;
+}
 
 function current(dir: string): string | null {
   try {
@@ -58,9 +73,10 @@ function current(dir: string): string | null {
 }
 
 export function installRuntime(store: RuntimeStore, stations: Iterable<string>): boolean {
-  const wanted = packageText(dependenciesFor(store.manifest, stations));
-  const installed = existsSync(join(store.dir, 'node_modules', '.metro-installed'));
-  if (installed && current(store.dir) === wanted) return false;
+  const wanted = packageText(dependenciesFor(store.manifest, stations), store.manifest.patchedDependencies ?? {});
+  const marker = join(store.dir, 'node_modules', '.metro-installed');
+  if (existsSync(marker) && current(store.dir) === wanted) return false;
+  rmSync(marker, { force: true });
   mkdirSync(store.dir, { recursive: true });
   writeFileSync(join(store.dir, 'package.json'), wanted);
   log.info({ dir: store.dir }, 'runtime: installing the channel SDKs this machine needs');
@@ -71,7 +87,7 @@ export function installRuntime(store: RuntimeStore, stations: Iterable<string>):
   });
   if (run.error !== undefined || run.status !== 0)
     throw new Error(`bun install failed in ${store.dir}: ${run.error?.message ?? `exit ${String(run.status)}`}`);
-  writeFileSync(join(store.dir, 'node_modules', '.metro-installed'), `${new Date().toISOString()}\n`);
+  writeFileSync(marker, `${new Date().toISOString()}\n`);
   return true;
 }
 

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

@@ -5,6 +5,7 @@ const RATE = 48_000;
 const FRAME = 960;
 const FRAME_MS = 20;
 const MAX_LATE_FRAMES = 5;
+const MAX_QUEUED_FRAMES = 3_000;
 
 interface Frame {
   pcm: Int16Array;
@@ -55,7 +56,7 @@ export class OpusIn {
 }
 
 export interface Playback {
-  send(opus: Buffer, timestamp: number, marker: boolean): void;
+  send(opus: Buffer, timestamp: number, marker: boolean): void | Promise<void>;
   played(chars: number): void;
 }
 
@@ -70,11 +71,15 @@ export class Player {
   private speaking = false;
   private onIdle: (() => void) | null = null;
   private onFirst: (() => void) | null = null;
+  private onFailed: ((reason: string) => void) | null = null;
+  private generation = 0;
+  private inFlight = 0;
+  private closed = false;
 
   constructor(private readonly out: Playback) {}
 
   get busy(): boolean {
-    return this.queue.length > 0 || this.pending.length > 0;
+    return this.queue.length > 0 || this.pending.length > 0 || this.inFlight > 0;
   }
 
   whenFirstPlayed(fn: () => void): void {
@@ -85,7 +90,16 @@ export class Player {
     this.onIdle = fn;
   }
 
+  whenFailed(fn: (reason: string) => void): void {
+    this.onFailed = fn;
+  }
+
   push(pcm: Int16Array, chars: number): void {
+    if (this.closed) return;
+    if (this.queue.length + this.inFlight + Math.ceil((this.pending.length + pcm.length) / FRAME) > MAX_QUEUED_FRAMES) {
+      this.failed('audio queue is full');
+      return;
+    }
     const joined = new Int16Array(this.pending.length + pcm.length);
     joined.set(this.pending);
     joined.set(pcm, this.pending.length);
@@ -101,7 +115,7 @@ export class Player {
   }
 
   finish(): void {
-    if (this.pending.length === 0) return;
+    if (this.closed || this.pending.length === 0) return;
     const pcm = new Int16Array(FRAME);
     pcm.set(this.pending);
     this.queue.push({ pcm, chars: this.pendingChars });
@@ -110,28 +124,36 @@ export class Player {
   }
 
   clear(): void {
+    this.generation += 1;
+    this.inFlight = 0;
+    this.speaking = false;
     this.queue.length = 0;
     this.pending = new Int16Array(0);
     this.pendingChars = 0;
   }
 
   start(): void {
-    if (this.timer !== null) return;
+    if (this.closed || this.timer !== null) return;
     this.started = performance.now();
     this.sent = 0;
     this.tick();
   }
 
   stop(): void {
+    if (this.closed) return;
+    this.closed = true;
     if (this.timer !== null) clearTimeout(this.timer);
     this.timer = null;
+    this.clear();
     this.encoder.delete();
   }
 
   private tick(): void {
+    if (this.closed) return;
     const due = Math.floor((performance.now() - this.started) / FRAME_MS) + 1;
     if (due - this.sent > MAX_LATE_FRAMES) this.sent = due - 1;
-    while (this.sent < due) this.sendOne();
+    while (!this.closed && this.sent < due) this.sendOne();
+    if (this.closed) return;
     const next = this.started + this.sent * FRAME_MS;
     this.timer = setTimeout(() => {
       this.tick();
@@ -143,11 +165,29 @@ export class Player {
     const marker = frame !== undefined && !this.speaking;
     this.speaking = frame !== undefined;
     const pcm = frame?.pcm ?? new Int16Array(FRAME);
-    this.out.send(this.encoder.encode(bytesOf(pcm), FRAME), (this.sent * FRAME) >>> 0, marker);
+    const timestamp = (this.sent * FRAME) >>> 0;
     this.sent += 1;
-    if (frame === undefined) return;
-    if (marker) this.onFirst?.();
-    if (frame.chars > 0) this.out.played(frame.chars);
-    if (!this.busy) this.onIdle?.();
+    const generation = this.generation;
+    if (frame !== undefined) this.inFlight += 1;
+    try {
+      const sent = this.out.send(this.encoder.encode(bytesOf(pcm), FRAME), timestamp, marker);
+      Promise.resolve(sent).then(() => {
+        if (this.closed || generation !== this.generation || frame === undefined) return;
+        this.inFlight -= 1;
+        if (marker) this.onFirst?.();
+        if (frame.chars > 0) this.out.played(frame.chars);
+        if (!this.busy) this.onIdle?.();
+      }).catch((err: unknown) => {
+        if (!this.closed && generation === this.generation) this.failed(errMsg(err));
+      });
+    } catch (err) {
+      if (!this.closed && generation === this.generation) this.failed(errMsg(err));
+    }
+  }
+
+  private failed(reason: string): void {
+    this.clear();
+    log.warn({ reason }, 'voice: audio playback failed');
+    this.onFailed?.(reason);
   }
 }

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

@@ -50,15 +50,21 @@ function streamEvent(msg: Record<string, unknown>, mind: Thinking): void {
   if (event.type === 'content_block_start' && block.type === 'tool_use') mind.tool(typeof block.name === 'string' ? block.name : 'tool');
 }
 
+function startBrain(model: string): ChildProcessWithoutNullStreams {
+  const [command = 'metro', ...args] = metroCli(['voice', '--model', model]);
+  const [file, argv] = asAgent(command, args);
+  return spawn(file, argv, { stdio: ['pipe', 'pipe', 'pipe'], cwd: '/' });
+}
+
 export class Brain {
   private readonly child: ChildProcessWithoutNullStreams;
   private out = '';
   private gone = false;
+  private closing = false;
+  private killTimer: ReturnType<typeof setTimeout> | undefined;
 
-  constructor(model: string, private readonly mind: Thinking) {
-    const [command = 'metro', ...args] = metroCli(['voice', '--model', model]);
-    const [file, argv] = asAgent(command, args);
-    this.child = spawn(file, argv, { stdio: ['pipe', 'pipe', 'pipe'], cwd: '/' });
+  constructor(model: string, private readonly mind: Thinking, launch = startBrain) {
+    this.child = launch(model);
     this.child.stdout.setEncoding('utf8');
     this.child.stdout.on('data', (chunk: string) => {
       this.out = drainLines('voice-brain', this.out + chunk, (line) => {
@@ -91,18 +97,22 @@ export class Brain {
   }
 
   close(): void {
-    if (this.gone) return;
+    if (this.gone || this.closing) return;
+    this.closing = true;
     this.child.stdin.end();
-    setTimeout(() => {
+    this.child.kill('SIGTERM');
+    this.killTimer = setTimeout(() => {
       if (!this.gone) this.child.kill('SIGKILL');
-    }, CLOSE_GRACE_MS).unref();
+    }, CLOSE_GRACE_MS);
+    this.killTimer.unref();
   }
 
   private write(message: Record<string, unknown>): void {
-    if (!this.gone && this.child.stdin.writable) this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    if (!this.gone && !this.closing && this.child.stdin.writable) this.child.stdin.write(`${JSON.stringify(message)}\n`);
   }
 
   private read(line: string): void {
+    if (this.closing || this.gone) return;
     let parsed: unknown;
     try {
       parsed = JSON.parse(line);
@@ -130,6 +140,7 @@ export class Brain {
   private exit(reason: string): void {
     if (this.gone) return;
     this.gone = true;
-    this.mind.exited(reason);
+    clearTimeout(this.killTimer);
+    if (!this.closing) this.mind.exited(reason);
   }
 }