@stage-labs/metro 0.1.0-beta.21 → 0.1.0-beta.210

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

@@ -0,0 +1,244 @@
+type Key = string;
+
+interface UsageWindow {
+  label: string;
+  used: number | null;
+  resetAt: string | null;
+  detail: string | null;
+}
+
+interface Tally {
+  requests: number;
+  input: number;
+  output: number;
+  cached: number;
+  since: string;
+}
+
+export interface ProviderUsage {
+  windows: UsageWindow[];
+  note: string | null;
+  at: string;
+  tally: Tally | null;
+}
+
+type Reported = Omit<ProviderUsage, 'tally'>;
+
+const latest = new Map<Key, Reported>();
+const tallies = new Map<Key, Tally>();
+
+export const noteUsage = (key: Key, usage: Reported): void => {
+  latest.set(key, usage);
+};
+
+export function usageSeen(): Record<Key, ProviderUsage> {
+  const out: Record<Key, ProviderUsage> = {};
+  for (const key of new Set<Key>([...latest.keys(), ...tallies.keys()])) {
+    const reported = latest.get(key);
+    const tally = tallies.get(key) ?? null;
+    out[key] = reported === undefined ? { windows: [], note: null, at: tally?.since ?? new Date().toISOString(), tally } : { ...reported, tally };
+  }
+  return out;
+}
+
+export const usageOf = (key: Key): Reported | undefined => latest.get(key);
+
+export const forgetOne = (key: Key): void => {
+  latest.delete(key);
+  tallies.delete(key);
+};
+
+export const forgetUsage = (): void => {
+  latest.clear();
+  tallies.clear();
+};
+
+export interface Counted {
+  input: number;
+  output: number;
+  cached: number;
+}
+
+export function tallyTokens(key: Key, counted: Counted, now = new Date()): void {
+  const so = tallies.get(key) ?? { requests: 0, input: 0, output: 0, cached: 0, since: now.toISOString() };
+  tallies.set(key, {
+    requests: so.requests + 1,
+    input: so.input + counted.input,
+    output: so.output + counted.output,
+    cached: so.cached + counted.cached,
+    since: so.since,
+  });
+}
+
+const TOKEN_FIELD = /"(input_tokens|output_tokens|cache_read_input_tokens|cache_creation_input_tokens)"\s*:\s*(\d+)/g;
+
+export class UsageScanner {
+  private carry = '';
+  private readonly max = { input: 0, output: 0, read: 0, creation: 0 };
+  private touched = false;
+
+  constructor(private readonly key: Key) {}
+
+  private scan(text: string): void {
+    for (const hit of text.matchAll(TOKEN_FIELD)) {
+      const value = Number(hit[2]);
+      if (!Number.isFinite(value)) continue;
+      this.touched = true;
+      if (hit[1] === 'input_tokens') this.max.input = Math.max(this.max.input, value);
+      else if (hit[1] === 'output_tokens') this.max.output = Math.max(this.max.output, value);
+      else if (hit[1] === 'cache_read_input_tokens') this.max.read = Math.max(this.max.read, value);
+      else this.max.creation = Math.max(this.max.creation, value);
+    }
+  }
+
+  feed(text: string): void {
+    const joined = this.carry + text;
+    const cut = joined.lastIndexOf('\n');
+    if (cut === -1) {
+      this.carry = joined;
+      return;
+    }
+    this.scan(joined.slice(0, cut));
+    this.carry = joined.slice(cut + 1);
+  }
+
+  done(now = new Date()): void {
+    if (this.carry !== '') this.scan(this.carry);
+    this.carry = '';
+    if (!this.touched) return;
+    tallyTokens(this.key, { input: this.max.input, output: this.max.output, cached: this.max.read + this.max.creation }, now);
+    this.touched = false;
+  }
+}
+
+const clamp = (value: number): number => Math.min(1, Math.max(0, value));
+
+function fraction(raw: string | null): number | null {
+  if (raw === null) return null;
+  const value = Number(raw);
+  return Number.isFinite(value) ? clamp(value) : null;
+}
+
+const MS_THRESHOLD = 1e12;
+
+function whenFrom(raw: string | null, now: Date, relative = false): string | null {
+  if (raw === null || raw.trim() === '') return null;
+  const numeric = Number(raw);
+  if (Number.isFinite(numeric)) {
+    const absolute = numeric > MS_THRESHOLD ? numeric : numeric * 1000;
+    const ms = relative ? now.getTime() + numeric * 1000 : absolute;
+    return new Date(ms).toISOString();
+  }
+  const parsed = Date.parse(raw);
+  return Number.isNaN(parsed) ? null : new Date(parsed).toISOString();
+}
+
+const ANTHROPIC_WINDOWS: [string, string][] = [
+  ['5h', '5-hour window'],
+  ['7d', 'Weekly'],
+  ['7d_sonnet', 'Weekly, Sonnet'],
+];
+
+function anthropicUnified(headers: Headers, now: Date): { windows: UsageWindow[]; note: string | null } {
+  const windows: UsageWindow[] = [];
+  let note: string | null = null;
+  for (const [key, label] of ANTHROPIC_WINDOWS) {
+    const used = fraction(headers.get(`anthropic-ratelimit-unified-${key}-utilization`));
+    if (used === null) continue;
+    const status = headers.get(`anthropic-ratelimit-unified-${key}-status`);
+    const blocked = status !== null && status !== 'allowed' ? status.replaceAll('_', ' ') : null;
+    if (blocked !== null && note === null) note = `${label}: ${blocked}`;
+    windows.push({ label, used, resetAt: whenFrom(headers.get(`anthropic-ratelimit-unified-${key}-reset`), now), detail: blocked });
+  }
+  return { windows, note };
+}
+
+function anthropicKeyed(headers: Headers, now: Date): UsageWindow[] {
+  const limit = Number(headers.get('anthropic-ratelimit-tokens-limit'));
+  const remaining = Number(headers.get('anthropic-ratelimit-tokens-remaining'));
+  if (!Number.isFinite(limit) || !Number.isFinite(remaining) || limit <= 0) return [];
+  return [
+    {
+      label: 'Tokens per minute',
+      used: clamp(1 - remaining / limit),
+      resetAt: whenFrom(headers.get('anthropic-ratelimit-tokens-reset'), now),
+      detail: `${remaining.toLocaleString('en-US')} of ${limit.toLocaleString('en-US')} left`,
+    },
+  ];
+}
+
+export function anthropicUsage(headers: Headers, now = new Date()): Reported | null {
+  const unified = anthropicUnified(headers, now);
+  if (unified.windows.length > 0) return { ...unified, at: now.toISOString() };
+  const keyed = anthropicKeyed(headers, now);
+  return keyed.length === 0 ? null : { windows: keyed, note: null, at: now.toISOString() };
+}
+
+const MINUTES_PER_HOUR = 60;
+const MINUTES_PER_DAY = 24 * MINUTES_PER_HOUR;
+const MINUTES_PER_WEEK = 7 * MINUTES_PER_DAY;
+
+export function windowLabel(minutes: number | null): string {
+  if (minutes === null || !Number.isFinite(minutes) || minutes <= 0) return 'Usage window';
+  if (minutes === MINUTES_PER_WEEK) return 'Weekly';
+  if (minutes % MINUTES_PER_DAY === 0) return `${String(minutes / MINUTES_PER_DAY)}-day window`;
+  if (minutes % MINUTES_PER_HOUR === 0) return `${String(minutes / MINUTES_PER_HOUR)}-hour window`;
+  return `${String(minutes)}-minute window`;
+}
+
+function codexWindow(headers: Headers, kind: 'primary' | 'secondary', now: Date): UsageWindow | null {
+  const raw = headers.get(`x-codex-${kind}-used-percent`);
+  if (raw === null) return null;
+  const percent = Number(raw);
+  if (!Number.isFinite(percent)) return null;
+  const used = clamp(percent / 100);
+  const minutes = Number(headers.get(`x-codex-${kind}-window-minutes`) ?? 'none');
+  const absolute = whenFrom(headers.get(`x-codex-${kind}-reset-at`), now);
+  const resetAt = absolute ?? whenFrom(headers.get(`x-codex-${kind}-reset-after-seconds`), now, true);
+  return { label: windowLabel(Number.isFinite(minutes) ? minutes : null), used, resetAt, detail: null };
+}
+
+function codexCredits(headers: Headers): UsageWindow | null {
+  if (headers.get('x-codex-credits-has-credits') !== 'true') return null;
+  const balance = Number(headers.get('x-codex-credits-balance') ?? 'none');
+  if (!Number.isFinite(balance)) return null;
+  return { label: 'Credits', used: null, resetAt: null, detail: `${balance.toLocaleString('en-US')} left` };
+}
+
+export function codexUsage(headers: Headers, now = new Date()): Reported | null {
+  const windows = [codexWindow(headers, 'primary', now), codexWindow(headers, 'secondary', now), codexCredits(headers)].filter(
+    (w): w is UsageWindow => w !== null,
+  );
+  if (windows.length === 0) return null;
+  const reached = headers.get('x-codex-rate-limit-reached-type');
+  return { windows, note: reached === null || reached === '' ? null : reached.replaceAll('_', ' '), at: now.toISOString() };
+}
+
+export function noteUsageHeaders(kind: 'anthropic' | 'codex', key: Key, headers: Headers, now = new Date()): void {
+  const usage = kind === 'anthropic' ? anthropicUsage(headers, now) : codexUsage(headers, now);
+  if (usage !== null) noteUsage(key, usage);
+}
+
+const dollars = (value: number): string => `$${value.toFixed(2)}`;
+
+export interface QuotaRow {
+  id: string;
+  remaining: number | null;
+  resetAt: string | null;
+}
+
+export function geminiUsage(rows: QuotaRow[], now = new Date()): Reported | null {
+  const windows: UsageWindow[] = rows
+    .filter((row) => row.remaining !== null)
+    .map((row) => ({ label: row.id, used: clamp(1 - (row.remaining ?? 0)), resetAt: row.resetAt, detail: null }));
+  return windows.length === 0 ? null : { windows, note: null, at: now.toISOString() };
+}
+
+export function openrouterUsage(total: number, spent: number, now = new Date()): Reported {
+  const used = total > 0 ? clamp(spent / total) : null;
+  return {
+    windows: [{ label: 'Credits', used, resetAt: null, detail: `${dollars(spent)} of ${dollars(total)} used` }],
+    note: null,
+    at: now.toISOString(),
+  };
+}

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

@@ -1,17 +1,12 @@
-import { forwardTrainCall } from '../daemon/train-call.js';
+import { storedPolicy } from '../policy/policy.js';
+import { forwardTrainCall } from '../stations/train-call.js';
 import {
   accountStationNames,
   stationByName,
 } from '../stations/registry.js';
-import { listEndpoints } from '../daemon/tunnel.js';
-import { hookUrl } from '../stations/attach.js';
-import { agentIdForAccount } from '../db/agent-map.js';
-import {
-  listAllStations,
-  stationRunsHere,
-  type StationRecord,
-} from '../db/materialize.js';
-import { type StationName } from '../db/schema.js';
+import { listEndpoints } from '../stations/webhook-endpoints.js';
+import { hookUrl, threemaCallbackUrl } from '../stations/attach.js';
+import { accountEnabled, agentIdForAccount, allowlistForAccount, approversForAccount, knownAccounts, type KnownAccount } from '../agents/map.js';
 
 const accountId = (acc: unknown): string | undefined => {
   const id = (acc as { id?: unknown }).id;
@@ -29,7 +24,14 @@ function withAgentId(station: string, acc: unknown): unknown {
   const id = typeof rec.id === 'string' ? rec.id : undefined;
   if (id === undefined) return acc;
   const agentId = agentIdForAccount(station, id);
-  return agentId === undefined ? acc : { ...rec, agentId };
+  if (agentId === undefined) return acc;
+  const allowlist = allowlistForAccount(station, id);
+  const stored = storedPolicy({ kind: 'channel', station, account: id });
+  const policy = stored === undefined ? {} : { policy: stored };
+  const approvers = approversForAccount(station, id);
+  const extra = approvers.length === 0 ? policy : { ...policy, approvers };
+  const tagged = allowlist === undefined ? { ...rec, agentId, ...extra } : { ...rec, agentId, allowlist, ...extra };
+  return accountEnabled(station, id) ? tagged : { ...tagged, enabled: false };
 }
 
 export function attachAgentIds(
@@ -75,6 +77,17 @@ function inCoreAccounts(station: string): unknown[] {
   );
 }
 
+function withCallbackUrl(acc: unknown): unknown {
+  const rec = asRecord(acc);
+  if (rec === undefined) return acc;
+  const { callbackId, callbackToken, ...rest } = rec;
+  if (typeof callbackId !== 'string' || typeof callbackToken !== 'string') return rest;
+  return { ...rest, callback: threemaCallbackUrl(callbackId, callbackToken) };
+}
+
+const decorate = (station: string, rows: unknown[]): unknown[] =>
+  station === 'threema' ? rows.map(withCallbackUrl) : rows;
+
 export interface ScopedAccounts {
   accounts: Record<string, unknown[]>;
   unavailable: string[];
@@ -85,12 +98,10 @@ async function liveAccounts(
 ): Promise<{ rows: unknown[]; reachable: boolean }> {
   if (!hasTrain(station))
     return { rows: inCoreAccounts(station), reachable: true };
-  if (!stationRunsHere(station as StationName))
-    return { rows: [], reachable: true };
   try {
     const resp = await forwardTrainCall(station, 'accounts', {});
     const list = (resp.result as { accounts?: unknown[] } | undefined)?.accounts;
-    return { rows: Array.isArray(list) ? list : [], reachable: true };
+    return { rows: decorate(station, Array.isArray(list) ? list : []), reachable: true };
   } catch {
     return { rows: [], reachable: false };
   }
@@ -99,7 +110,7 @@ async function liveAccounts(
 function mergeKnown(
   station: string,
   live: unknown[],
-  known: StationRecord[],
+  known: KnownAccount[],
 ): unknown[] {
   const seen = new Set(
     live.flatMap((row) => {
@@ -116,12 +127,12 @@ function mergeKnown(
 async function loadStations(): Promise<ScopedAccounts> {
   const unavailable: string[] = [];
   const accounts: Record<string, unknown[]> = {};
-  const known = await listAllStations();
+  const known = knownAccounts();
   await Promise.all(
     accountStationNames().map(async (station) => {
       const { rows, reachable } = await liveAccounts(station);
       if (!reachable) unavailable.push(station);
-      accounts[station] = mergeKnown(station, rows, known);
+      accounts[station] = hasTrain(station) ? mergeKnown(station, rows, known) : rows;
     }),
   );
   return { accounts, unavailable };

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

@@ -0,0 +1,91 @@
+import type { ToolDef } from './tool-def.js';
+
+export const attachmentItem = {
+  type: 'object',
+  description:
+    'A file to attach. Provide EXACTLY ONE source; naming two is an error and so is naming ' +
+    'none. Which one to use: `upload` for any real file on your own machine, including a ' +
+    'confidential one (call `create_upload` first, push the bytes over HTTP, then name the ' +
+    'id here); `data` ONLY for a tiny file, a few KB at most, because the base64 has to be ' +
+    'written out verbatim in this tool call and long base64 gets corrupted in the writing; ' +
+    '`url` when the file is ALREADY published somewhere the daemon can fetch it; `path` ONLY ' +
+    'for a file that is already sitting on the daemon host, which is almost never your ' +
+    'machine.',
+  properties: {
+    upload: {
+      type: 'string',
+      description:
+        'The `upload_id` of a file already pushed to metro over HTTP (`create_upload` mints ' +
+        'the slot and the one-line command; the bytes never pass through this conversation). ' +
+        'THIS IS THE ROUTE FOR ANYTHING REAL: it takes files up to 64 MiB, works for a file on ' +
+        'your own machine, and publishes nothing. The upload belongs to your agent, expires ' +
+        '30 minutes after it is created, and no other agent can name it.',
+    },
+    data: {
+      type: 'string',
+      description:
+        'Base64-encoded file bytes, inline in this call. ONLY FOR TINY FILES. The hard cap is ' +
+        '8 MiB decoded, but the real ceiling is far lower and is not enforced by the daemon: ' +
+        'this base64 has to be emitted verbatim as part of the tool call, and past roughly ' +
+        '10 KB (~13 KB of base64) it comes out corrupted, so the file arrives silently ' +
+        'damaged or fails to decode. Use `upload` instead for anything bigger. A ' +
+        '`data:<mime>;base64,` prefix is accepted and supplies the mime when `mime` is ' +
+        'omitted. Stations impose their own, lower limits (xmtp refuses non-image files over ' +
+        '~190 KiB).',
+    },
+    url: {
+      type: 'string',
+      description:
+        'http(s) URL fetched BY THE DAEMON, so it must already be publicly reachable from the ' +
+        'daemon host. Right when the file is already published; never for anything ' +
+        'confidential, because it has to be public for this to work at all. Use `upload` for ' +
+        'a confidential file.',
+    },
+    path: {
+      type: 'string',
+      description:
+        'Absolute path resolved ON THE DAEMON HOST, which is a different machine from yours. ' +
+        'A path on your own disk does NOT resolve here and is refused, however local it ' +
+        'looks. Use `upload` for a file on your machine.',
+    },
+    mime: {
+      type: 'string',
+      description: 'MIME type (guessed from the name/extension if omitted).',
+    },
+    name: {
+      type: 'string',
+      description:
+        'Filename to present (defaults to the basename, or to the name given at upload time).',
+    },
+  },
+} as const;
+
+export const CREATE_UPLOAD_TOOL: ToolDef = {
+  name: 'create_upload',
+  group: 'write',
+  description:
+    'Reserve a slot to push a file to metro over HTTP so you can attach it with `send`. Use ' +
+    'this for any file that actually matters: it is the only attachment route that carries a ' +
+    'file from YOUR machine without publishing it and without the bytes passing through this ' +
+    'conversation. Args: name? (the filename to present), mime?. Returns `upload_id`, a ' +
+    'single-use `upload_url` and a ready-to-run `curl` line. ONE STEP NEEDS A SHELL: run that ' +
+    'command (or any HTTP client) to push the bytes; there is no way to move a local file to ' +
+    'the daemon over MCP alone, because anything in an MCP call has to be written out by the ' +
+    'model first. If you have no shell, hand the single command to a subagent that does and ' +
+    'keep the `upload_id` -- the slot belongs to this metro agent, not to whoever runs the ' +
+    'command. Then: send({line, attachments:[{upload:"<upload_id>"}]}). Up to 64 MiB, expires ' +
+    '30 minutes after it is created, and no other agent can reference it.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string',
+        description: 'Filename to present to the recipient (e.g. `report.pdf`).',
+      },
+      mime: {
+        type: 'string',
+        description: 'MIME type (guessed from the name/extension if omitted).',
+      },
+    },
+  },
+};

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

@@ -1,14 +1,15 @@
 import { stationForLine } from '../stations/registry.js';
-import { kindOf, toCanonical } from '../stations/attachments.js';
+import { kindOf, toCanonical } from '@metro-labs/core/stations/attachments';
 import {
   cleanupAttachments,
   resolveAttachments,
   type ResolvedAttachment,
 } from '../stations/attach-resolve.js';
-import type { CanonicalAttachment, ToolResult } from '../stations/types.js';
-import { errResult, makeCtx, ok, okJson, toErr } from './ctx.js';
+import type { CanonicalAttachment, ToolResult } from '@metro-labs/core/stations/types';
+import { errResult, makeCtx, ok, toErr } from './ctx.js';
+import { runRead } from './read-tool.js';
 import { allowedAgents, currentIdentity } from './request-identity.js';
-import { str } from './str.js';
+import { str } from '@metro-labs/core/str';
 
 type Station = NonNullable<ReturnType<typeof stationForLine>>;
 
@@ -16,6 +17,7 @@ interface MessageArgs {
   line: string;
   a: Record<string, unknown>;
   ctx: ReturnType<typeof makeCtx>;
+  onSent?: (messageId: string) => void;
   station: Station;
 }
 
@@ -30,8 +32,14 @@ const withId = (text: string, messageId: string | undefined): string =>
 interface Sent {
   labels: string[];
   messageId?: string;
+  thread?: string;
 }
 
+const threadOf = (response: { result: unknown }, asked: string): string | undefined => {
+  const line = (response.result as { line?: unknown } | null)?.line;
+  return typeof line === 'string' && line !== '' && line !== asked ? line : undefined;
+};
+
 const deliveredLabels = (response: { result: unknown }): string[] => {
   const list = (response.result as { attachments?: unknown } | null)
     ?.attachments;
@@ -87,17 +95,20 @@ async function sendForwarded(
   const { line, ctx, station } = m;
   const args: Record<string, unknown> = { line };
   if (text) args.text = text;
+  if (typeof m.a.subject === 'string' && m.a.subject.trim() !== '') args.subject = m.a.subject;
   if (replyTo) args.replyTo = replyTo;
   if (atts.length) args.attachments = atts.map(toCanonical);
   const response = await ctx.call('send', args);
   const messageId = messageIdOf(response);
+  const thread = threadOf(response, line);
   const labels: string[] = [];
   if (text) labels.push('text');
-  if (!atts.length) return { labels, messageId };
-  const delivered = deliveredLabels(response);
-  assertDelivered(station, delivered, atts);
-  labels.push(...delivered);
-  return { labels, messageId };
+  if (atts.length) {
+    const delivered = deliveredLabels(response);
+    assertDelivered(station, delivered, atts);
+    labels.push(...delivered);
+  }
+  return thread === undefined ? { labels, messageId } : { labels, messageId, thread };
 }
 
 const unsupported = (station: Station, atts: CanonicalAttachment[]): string =>
@@ -105,6 +116,10 @@ const unsupported = (station: Station, atts: CanonicalAttachment[]): string =>
     .map((a) => kindOf(a.mime ?? '', a.path ?? a.url ?? a.name ?? ''))
     .join(', ')}); send a link in \`text\` instead`;
 
+function noteSent(m: MessageArgs, messageId: string | undefined): void {
+  if (messageId !== undefined) m.onSent?.(messageId);
+}
+
 async function handleSend(m: MessageArgs): Promise<ToolResult> {
   const text = m.a.text as string | undefined;
   const replyTo = m.a.reply_to as string | undefined;
@@ -125,19 +140,15 @@ async function handleSend(m: MessageArgs): Promise<ToolResult> {
       : await sendForwarded(m, text, replyTo, atts);
     if (!sent.labels.length)
       return errResult('send requires `text` or `attachments`');
-    return ok(withId(`sent: ${sent.labels.join(', ')}`, sent.messageId));
+    noteSent(m, sent.messageId);
+    const done = withId(`sent: ${sent.labels.join(', ')}`, sent.messageId);
+    return ok(sent.thread === undefined ? done : `${done} — new thread line: ${sent.thread}`);
   } finally {
     await cleanupAttachments(atts);
   }
 }
 
-async function handleRead({ line, a, ctx }: MessageArgs): Promise<ToolResult> {
-  const args: Record<string, unknown> = { line };
-  if (typeof a.limit === 'number') args.limit = a.limit;
-  if (a.before) args.before = str(a.before);
-  if (a.since) args.since = str(a.since);
-  return okJson(await ctx.call('read', args));
-}
+const handleRead = ({ a, station }: MessageArgs): Promise<ToolResult> => runRead(station, a);
 
 type MessageHandler = (m: MessageArgs) => Promise<ToolResult>;
 
@@ -158,7 +169,7 @@ const MESSAGE_VERBS: Record<string, VerbSpec> = {
 };
 
 function makeVerbHandler(verb: string, spec: VerbSpec): MessageHandler {
-  return async ({ line, a, ctx }) => {
+  return async ({ line, a, ctx, onSent }) => {
     const payload: Record<string, unknown> = { line };
     for (const [snake, camel] of spec.args) {
       const value = str(a[snake]);
@@ -169,21 +180,34 @@ function makeVerbHandler(verb: string, spec: VerbSpec): MessageHandler {
       payload[camel] = value;
     }
     const response = await ctx.call(verb, payload);
-    return ok(withId(spec.success, messageIdOf(response)));
+    const messageId = messageIdOf(response);
+    if (verb === 'reply' && messageId !== undefined) onSent?.(messageId);
+    return ok(withId(spec.success, messageId));
   };
 }
 
+const handleTyping = async ({ line, ctx }: MessageArgs): Promise<ToolResult> => {
+  await ctx.call('typing', { line });
+  return ok('typing shown');
+};
+
 const MESSAGE_HANDLERS: Record<string, MessageHandler> = {
   send: handleSend,
   read: handleRead,
+  typing: handleTyping,
   ...Object.fromEntries(
     Object.entries(MESSAGE_VERBS).map(([verb, spec]) => [verb, makeVerbHandler(verb, spec)]),
   ),
 };
 
+export interface ToolHooks {
+  onSent?: (messageId: string) => void;
+}
+
 export async function dispatchMessageTool(
   name: string,
   a: Record<string, unknown>,
+  hooks: ToolHooks = {},
 ): Promise<ToolResult> {
   const line = str(a.line);
   if (!line) return errResult(`${name} requires \`line\``);
@@ -195,8 +219,13 @@ export async function dispatchMessageTool(
   }
   const handler = MESSAGE_HANDLERS[name];
   if (!handler) return errResult(`unknown tool: ${name}`);
+  const verbs: ReadonlySet<string> = station.messageVerbs;
+  if (!verbs.has(name))
+    return errResult(
+      `${station.name} does not support ${name}; it supports ${[...verbs].join(', ')}.`,
+    );
   try {
-    return await handler({ line, a, ctx: makeCtx(station.name), station });
+    return await handler({ line, a, ctx: makeCtx(station.name), station, onSent: hooks.onSent });
   } catch (e) {
     return toErr(name, e);
   }

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

@@ -1,8 +1,8 @@
 import { readFile } from 'node:fs/promises';
-import { forwardTrainCall } from '../daemon/train-call.js';
-import { errMsg, log } from '../daemon/log.js';
-import { TrainError } from '../daemon/train-error.js';
-import { type ToolContext, type ToolResult } from '../stations/types.js';
+import { forwardTrainCall } from '../stations/train-call.js';
+import { errMsg, log } from '@metro-labs/core/log';
+import { TrainError } from '@metro-labs/core/train-error';
+import { type ToolContext, type ToolResult } from '@metro-labs/core/stations/types';
 
 export async function metroCall(
   train: string,