@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

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

@@ -0,0 +1,48 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { IncomingMessage } from 'node:http';
+import { cameThroughProxy } from '@metro-labs/http/api-http';
+import { agentIdForKey } from '../agents/keys.js';
+
+export interface RequestIdentity {
+  kind: 'agent';
+  agentId: string;
+}
+
+const storage = new AsyncLocalStorage<RequestIdentity>();
+
+export function runWithIdentity<T>(
+  identity: RequestIdentity,
+  fn: () => Promise<T>,
+): Promise<T> {
+  return storage.run(identity, fn);
+}
+
+export function currentIdentity(): RequestIdentity | undefined {
+  return storage.getStore();
+}
+
+export function extractToken(req: IncomingMessage): string | undefined {
+  const header = req.headers.authorization;
+  if (header?.startsWith('Bearer ')) {
+    const t = header.slice(7).trim();
+    if (t) return t;
+  }
+  const qt = new URL(req.url ?? '/', 'http://localhost').searchParams.get(
+    'token',
+  );
+  return qt ?? undefined;
+}
+
+export function authenticate(req: IncomingMessage): RequestIdentity | null {
+  if (cameThroughProxy(req)) return null;
+  const token = extractToken(req);
+  if (!token) return null;
+  const agentId = agentIdForKey(token);
+  return agentId === undefined ? null : { kind: 'agent', agentId };
+}
+
+export function allowedAgents(
+  identity: RequestIdentity | undefined,
+): Set<string> {
+  return identity ? new Set([identity.agentId]) : new Set();
+}

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

@@ -0,0 +1,108 @@
+import type { MetroEvent } from '@metro-labs/core/events';
+import { errMsg, log } from '@metro-labs/core/log';
+import type { McpApproval, McpDecision } from '@metro-labs/http/mcp-server-protocol';
+import { holdPrompt, isPromptHeld, type Behavior } from '../approvals/pending.js';
+import { ownerLine } from '../approvals/owner-line.js';
+import { metroNotice } from '../channels/notice.js';
+import { announcedLine, noteAnnounced } from '../mcp-server/announced.js';
+import type { AnswerOutcome } from '../mcp-server/link.js';
+import { serverPromptBody } from './permission-prompt.js';
+import { metroSend, relayLine } from './permission-relay.js';
+import { channelLog, type McpSession } from './session.js';
+
+const RECENT_MS = 10 * 60_000;
+const RECENT_MAX = 1_000;
+
+const owner = {};
+const recent = new Map<string, number>();
+let current: () => McpSession | undefined = () => undefined;
+
+export function connectServerApprovals(session: () => McpSession | undefined): void {
+  current = session;
+}
+
+function promptLineFor(requestId: string): string | undefined {
+  const session = current();
+  if (session === undefined) return undefined;
+  return relayLine({ relay: session.relay, inScope: (line) => session.inScope(line), live: session.live, log: channelLog }, requestId);
+}
+
+const noticeLineFor = (line: string | undefined): string | undefined => line ?? current()?.relay.knownLine ?? ownerLine()?.line;
+
+function remember(id: string, now = Date.now()): void {
+  for (const [seen, at] of recent) if (now - at >= RECENT_MS) recent.delete(seen);
+  recent.set(id, now);
+  while (recent.size > RECENT_MAX) {
+    const oldest = recent.keys().next();
+    if (oldest.done) break;
+    recent.delete(oldest.value);
+  }
+}
+
+const answeredRecently = (id: string, now = Date.now()): boolean => now - (recent.get(id) ?? -Infinity) < RECENT_MS;
+
+const noticeText = (tool: string, id: string, behavior: Behavior): string =>
+  behavior === 'allow' ? `Approved: ${tool} (${id}). Call tool_call again with the same arguments and approval: "${id}".` : `Denied: ${tool} (${id}).`;
+
+const requestedAt = (at: number, now = Date.now()): number => (Number.isFinite(at) && at > 0 ? Math.min(at, now) : now);
+
+interface Held {
+  id: string;
+  tool: string;
+  line: string | undefined;
+  answer: (decision: McpDecision) => Promise<AnswerOutcome>;
+  publish: (event: MetroEvent) => void;
+}
+
+async function deliver(held: Held, behavior: Behavior): Promise<void> {
+  const outcome = await held.answer(behavior);
+  if (outcome !== 'acknowledged') {
+    log.info({ id: held.id, outcome }, 'mcp-server: the answer was not taken, so the agent is not told');
+    return;
+  }
+  const line = noticeLineFor(held.line);
+  if (line === undefined) {
+    log.warn({ id: held.id }, 'mcp-server: no chat is known to tell the agent the answer');
+    return;
+  }
+  held.publish(metroNotice(line, noticeText(held.tool, held.id, behavior)));
+}
+
+function sender(held: Held): (behavior: Behavior) => Promise<void> {
+  return (behavior) => {
+    remember(held.id);
+    deliver(held, behavior).catch((err: unknown) => {
+      log.warn({ id: held.id, err: errMsg(err) }, 'mcp-server: the answer could not be delivered');
+    });
+    return Promise.resolve();
+  };
+}
+
+function announce(id: string, line: string, text: string): void {
+  metroSend(line, text).then(() => {
+    noteAnnounced(id, line);
+  }).catch((err: unknown) => {
+    log.warn({ id, err: errMsg(err) }, 'mcp-server: the approval prompt could not be posted');
+  });
+}
+
+export function holdServerApproval(approval: McpApproval, answer: Held['answer'], publish: Held['publish']): boolean {
+  if (isPromptHeld(approval.id) || answeredRecently(approval.id)) return false;
+  const tool = `${approval.connector}.${approval.tool}`;
+  const announced = announcedLine(approval.id);
+  const line = announced ?? promptLineFor(approval.id);
+  const held: Held = { id: approval.id, tool, line, answer, publish };
+  holdPrompt(
+    { requestId: approval.id, tool, description: approval.connector, preview: approval.preview, line, at: requestedAt(approval.requestedAt), origin: 'mcp-server' },
+    owner,
+    sender(held),
+    line === undefined ? undefined : async (text) => metroSend(line, text),
+  );
+  log.info({ id: approval.id, tool, inChat: line !== undefined, announced: announced !== undefined }, 'mcp-server: an approval is waiting for the owner');
+  if (line !== undefined && announced === undefined) announce(approval.id, line, serverPromptBody({ requestId: approval.id, tool, preview: approval.preview }));
+  return true;
+}
+
+export function forgetServerApprovals(): void {
+  recent.clear();
+}

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

@@ -0,0 +1,137 @@
+import { randomUUID } from 'node:crypto';
+import { currentBusSeq } from '@metro-labs/core/events';
+import { errMsg } from '@metro-labs/core/log';
+import { newReplayLedger } from '../channels/relay.js';
+import { McpSession, channelLog } from './session.js';
+import { allowedAgents, type RequestIdentity } from './request-identity.js';
+import { diagnosticTag, type SessionDiagnostic, type SlotDiagnostic } from './diagnostics.js';
+
+interface SlotReplacement {
+  at: string;
+  reason: 'initialize' | 'adopt';
+  tag: string;
+  scope: Set<string>;
+  previousScope: Set<string>;
+  previous: SessionDiagnostic | null;
+}
+
+const sharesScope = (left: Set<string>, right: Set<string>): boolean => [...left].some((id) => right.has(id));
+
+export class SessionSlot {
+  private session: McpSession | undefined;
+  private readonly ledger = newReplayLedger();
+  private started = false;
+  private live: boolean;
+  private changing: Promise<void> = Promise.resolve();
+  private readonly replacements: SlotReplacement[] = [];
+
+  constructor(live = true) {
+    this.live = live;
+  }
+
+  get current(): McpSession | undefined {
+    return this.session;
+  }
+
+  get liveEvents(): boolean {
+    return this.live;
+  }
+
+  diagnostics(scope: Set<string>): SlotDiagnostic {
+    return {
+      started: this.started,
+      liveEvents: this.live,
+      current: this.session !== undefined && sharesScope(scope, this.session.scope) ? this.session.diagnostics() : null,
+      replacements: this.replacements.filter((replacement) => sharesScope(scope, replacement.scope)).map((replacement) => ({
+        at: replacement.at,
+        reason: replacement.reason,
+        tag: replacement.tag,
+        previous: sharesScope(scope, replacement.previousScope) ? replacement.previous : null,
+      })),
+    };
+  }
+
+  startInbound(): void {
+    if (this.started) return;
+    this.started = true;
+    if (this.ledger.startAt < 0) this.ledger.startAt = currentBusSeq();
+    if (this.live) this.session?.startChannel();
+  }
+
+  setLive(on: boolean): void {
+    if (this.live === on) return;
+    this.live = on;
+    channelLog('inbound: live events', on ? 'on' : 'off');
+    if (!on) {
+      this.session?.stopChannel();
+      this.session?.relay.dropPending();
+      return;
+    }
+    this.ledger.startAt = currentBusSeq();
+    if (this.started) this.session?.startChannel();
+  }
+
+  open(identity: RequestIdentity, adoptId?: string): Promise<McpSession> {
+    return this.change(() => this.replace(identity, adoptId));
+  }
+
+  private change<T>(run: () => Promise<T>): Promise<T> {
+    const changed = this.changing.then(run);
+    this.changing = changed.then(() => undefined).catch((err: unknown) => {
+      channelLog('session: change failed', errMsg(err));
+    });
+    return changed;
+  }
+
+  private previousSlot(): Pick<SlotReplacement, 'previous' | 'previousScope'> {
+    return {
+      previous: this.session?.diagnostics() ?? null,
+      previousScope: this.session?.scope ?? new Set<string>(),
+    };
+  }
+
+  private recordReplacement(session: McpSession, adoptId: string | undefined, previous: Pick<SlotReplacement, 'previous' | 'previousScope'>): void {
+    this.replacements.push({
+      at: new Date().toISOString(),
+      reason: adoptId === undefined ? 'initialize' : 'adopt',
+      tag: diagnosticTag(session.id),
+      scope: session.scope,
+      ...previous,
+    });
+    if (this.replacements.length > 8) this.replacements.shift();
+  }
+
+  private async replace(identity: RequestIdentity, adoptId?: string): Promise<McpSession> {
+    if (adoptId !== undefined && this.session?.id === adoptId) return this.session;
+    const previous = this.previousSlot();
+    await this.session?.close();
+    if (this.ledger.startAt < 0) this.ledger.startAt = currentBusSeq();
+    const id = adoptId ?? randomUUID();
+    const session = await McpSession.open({
+      id,
+      scope: allowedAgents(identity),
+      adopted: adoptId !== undefined,
+      ledger: this.ledger,
+      live: () => this.live,
+      onClosed: (s) => {
+        if (this.session === s) this.session = undefined;
+        s.channel.whenIdle().then(() => {
+          if (this.session?.streamAttached) this.session.replayMissed();
+        }).catch((err: unknown) => {
+          channelLog('session: handoff replay failed', errMsg(err));
+        });
+      },
+    });
+    this.session = session;
+    this.recordReplacement(session, adoptId, previous);
+    if (this.started && this.live) session.startChannel();
+    channelLog('session: opened', 'id', id, 'adopted', adoptId !== undefined);
+    return session;
+  }
+
+  close(): Promise<void> {
+    return this.change(async () => {
+      await this.session?.close();
+    });
+  }
+}

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

@@ -1,20 +1,21 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { InboundRelay } from '../channels/inbound.js';
+import { answerPrompt, forgetPromptsOf, promptLine } from '../approvals/pending.js';
+import { noteOwnerLine } from '../approvals/owner-line.js';
 import { ChannelRelay, type ReplayLedger } from '../channels/relay.js';
-import { errMsg } from '../daemon/log.js';
-import {
-  allowlistForLine,
-  senderMatchesAllowlist,
-} from '../db/agent-map.js';
-import { accountStationNames } from '../stations/registry.js';
-import { MCP_INSTRUCTIONS } from './tool-schemas.js';
-import { ChannelOwner } from './channel-owner.js';
+import { errMsg } from '@metro-labs/core/log';
+import { allowlistForLine, mayApprove, senderPermitted } from '../agents/map.js';
+import { accountStationNames, stationByName } from '../stations/registry.js';
+import { eventInScope } from '../agents/scope.js';
+import { MCP_INSTRUCTIONS } from './instructions.js';
 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 type { RequestIdentity } from './request-identity.js';
+import { sharedCalls } from '../voice/shared.js';
+import { CALL_STATE } from '@metro-labs/core/call';
+import { clientDiagnostic, diagnosticTag, type SessionDiagnostic } from './diagnostics.js';
 
 export const channelLog = (...a: unknown[]): void => {
   console.error('[metro-mcp]', ...a);
@@ -22,11 +23,20 @@ export const channelLog = (...a: unknown[]): void => {
 
 const getStations = (): Set<string> => new Set(accountStationNames());
 
-const senderAllowed = (from: string, line: string): boolean => {
-  const allowlist = allowlistForLine(line);
-  return allowlist ? senderMatchesAllowlist(allowlist, from) : true;
+const senderAllowed = (from: string, line: string, verified?: boolean): boolean =>
+  senderPermitted(allowlistForLine(line), from, verified);
+
+const approves = (station: string): boolean => stationByName(station)?.approvals !== false;
+
+const noteDirect = (line: string, from: string): void => {
+  if (mayApprove(line, from)) noteOwnerLine(line, from);
 };
 
+async function answerPermission(requestId: string, behavior: 'allow' | 'deny', line: string, from: string): Promise<boolean> {
+  if (promptLine(requestId) !== line || !mayApprove(line, from)) return false;
+  return (await answerPrompt(requestId, behavior, 'chat', line)) !== undefined;
+}
+
 function makeTransport(
   id: string,
   eventStore: BoundedEventStore,
@@ -47,51 +57,48 @@ function makeTransport(
 
 export interface SessionInit {
   id: string;
-  scopeKey: string;
+  scope: Set<string>;
   adopted: boolean;
   ledger: ReplayLedger;
+  live: () => boolean;
   onClosed: (session: McpSession) => void;
 }
 
 export class McpSession {
   readonly id: string;
-  readonly scopeKey: string;
-  readonly owner = new ChannelOwner();
+  readonly scope: Set<string>;
   readonly eventStore: BoundedEventStore;
   readonly transport: StreamableHTTPServerTransport;
   readonly server: Server;
   readonly relay: InboundRelay;
   readonly channel: ChannelRelay;
-  lastSeenAt = Date.now();
+  readonly live: () => boolean;
   private sink: RawGetSink | undefined;
   private unsubscribe: (() => void) | undefined;
   private closed = false;
   private issuedSchema: string | undefined;
   private announcing = false;
   private readonly onClosed: (session: McpSession) => void;
+  private readonly openedAt = new Date().toISOString();
+  private clientInitializedAt: string | null = null;
+  private lastStreamAttachedAt: string | null = null;
+  private lastStreamDetachedAt: string | null = null;
 
   private constructor(init: SessionInit) {
     this.id = init.id;
-    this.scopeKey = init.scopeKey;
+    this.scope = init.scope;
+    this.live = init.live;
     this.issuedSchema = init.adopted ? undefined : toolSchemaSignature();
     this.onClosed = init.onClosed;
-    this.eventStore = new BoundedEventStore({
-      scopeOf: () => this.owner.scope(),
-    });
+    this.eventStore = new BoundedEventStore();
     this.transport = makeTransport(init.id, this.eventStore, init.adopted);
     this.server = new Server(
       { name: 'metro', version: '0.1.0' },
-      {
-        capabilities: {
-          experimental: {
-            'claude/channel': {},
-            'claude/channel/permission': {},
-          },
-          tools: { listChanged: true },
-        },
-        instructions: MCP_INSTRUCTIONS,
-      },
+      { capabilities: { tools: { listChanged: true } }, instructions: MCP_INSTRUCTIONS },
     );
+    this.server.oninitialized = (): void => {
+      this.clientInitializedAt = new Date().toISOString();
+    };
     registerToolHandlers(this.server, {
       markCurrent: (): void => {
         this.issuedSchema = toolSchemaSignature();
@@ -99,23 +106,32 @@ export class McpSession {
       deliver: (send): void => {
         this.deliverSchemaNotice(send, 'request');
       },
+    }, {
+      onSent: (id): void => {
+        this.relay.noteSent(id);
+      },
     });
     this.relay = new InboundRelay({
       mcp: this.server,
       log: channelLog,
       getStations,
       senderAllowed,
+      approves,
+      noteDirect,
+      answerPermission,
+      callMeta: (event) => sharedCalls.bindChat(event, this.scope),
     });
     registerPermissionRelay({
       mcp: this.server,
       relay: this.relay,
-      owner: this.owner,
+      inScope: (line) => this.inScope(line),
+      live: this.live,
       log: channelLog,
     });
     this.channel = new ChannelRelay({
       relay: this.relay,
       log: channelLog,
-      inScope: (line) => this.owner.inScope(line),
+      inScope: (line) => this.live() && this.inScope(line),
       ledger: init.ledger,
     });
   }
@@ -139,28 +155,70 @@ export class McpSession {
     return this.sink;
   }
 
-  touch(): void {
-    this.lastSeenAt = Date.now();
+  diagnostics(): SessionDiagnostic {
+    return {
+      tag: diagnosticTag(this.id),
+      openedAt: this.openedAt,
+      transportInitialized: web(this.transport)?._initialized === true,
+      clientInitializedAt: this.clientInitializedAt,
+      client: clientDiagnostic(this.server.getClientVersion()),
+      subscribed: this.unsubscribe !== undefined,
+      streamAttached: this.streamAttached,
+      lastStreamAttachedAt: this.lastStreamAttachedAt,
+      lastStreamDetachedAt: this.lastStreamDetachedAt,
+      stream: this.sink?.diagnostics() ?? null,
+    };
+  }
+
+  inScope(line: string): boolean {
+    return this.streamAttached && eventInScope(this.scope, line);
   }
 
   startChannel(): void {
     this.unsubscribe ??= this.channel.start();
   }
 
-  bindSink(sink: RawGetSink | undefined, identity: RequestIdentity): void {
-    this.sink = sink;
-    if (sink === undefined) {
-      this.owner.releaseStream();
+  stopChannel(): void {
+    this.unsubscribe?.();
+    this.unsubscribe = undefined;
+  }
+
+  replayMissed(): void {
+    if (this.live()) this.channel.replayMissed();
+  }
+
+  bindSink(sink: RawGetSink | undefined): void {
+    if (this.closed) {
+      sink?.close();
       return;
     }
-    this.owner.bindStream(identity);
-    this.announceToolSchema();
+    if (sink === undefined && this.sink !== undefined) this.lastStreamDetachedAt = new Date().toISOString();
+    this.sink = sink;
+    if (sink !== undefined) {
+      this.lastStreamAttachedAt = new Date().toISOString();
+      this.announceCallState();
+      this.announceToolSchema();
+    }
+  }
+
+  private announceCallState(): void {
+    if (!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 {
     return this.issuedSchema !== toolSchemaSignature();
   }
 
+  toolsChanged(): void {
+    this.announceToolSchema();
+  }
+
   private announceToolSchema(): void {
     if (!this.streamAttached) return;
     this.deliverSchemaNotice(
@@ -172,15 +230,7 @@ export class McpSession {
   private deliverSchemaNotice(send: () => Promise<void>, via: string): void {
     if (!this.schemaNoticeDue || this.announcing) return;
     this.announcing = true;
-    channelLog(
-      'session: tool list changed',
-      'id',
-      this.id,
-      'scope',
-      this.scopeKey,
-      'via',
-      via,
-    );
+    channelLog('session: tool list changed', 'id', this.id, 'via', via);
     send()
       .then(() => {
         this.issuedSchema = toolSchemaSignature();
@@ -194,18 +244,19 @@ export class McpSession {
 
   dropStream(): void {
     const sink = this.sink;
+    if (sink !== undefined) this.lastStreamDetachedAt = new Date().toISOString();
     this.sink = undefined;
-    this.owner.releaseStream();
     sink?.close();
   }
 
   async close(): Promise<void> {
     if (this.closed) return;
     this.closed = true;
+    sharedCalls.revoke();
     this.onClosed(this);
+    forgetPromptsOf(this.server);
     this.dropStream();
-    this.unsubscribe?.();
-    this.unsubscribe = undefined;
+    this.stopChannel();
     await this.server.close().catch(() => undefined);
   }
 }

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.' });
+}