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

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

@@ -0,0 +1,60 @@
+import type { ToolDef } from './tool-def.js';
+import { Line } from '@metro-labs/core/lines';
+import type { Station, ToolResult } from '@metro-labs/core/stations/types';
+import { str } from '@metro-labs/core/str';
+import { stationByName } from '../stations/registry.js';
+import { errResult, makeCtx, okJson, toErr } from './ctx.js';
+
+export const GET_PROFILE_TOOL: ToolDef = {
+  name: 'get_profile',
+  group: 'read',
+  description:
+    'Who is this person? Give the `from` attribute of one of their messages verbatim ' +
+    '(`metro://<station>/<account>/user/<id>`) and get what their network says about them: ' +
+    '{id, name, display_name, about, avatar, address}. XMTP answers the Basename ' +
+    '(<label>.stage.base.eth), its name, description and avatar records, and the wallet address; ' +
+    'WhatsApp the phone number, the name they last used, the about line and the picture; Telegram the handle, the name and the bio; Discord ' +
+    'the username, the global name and the avatar. Fields the network does not have are absent. ' +
+    'The answer is cached for ten minutes, so ask when you want to know someone, not on every message.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      from: { type: 'string', description: 'The `from` of a message, exactly as received.' },
+    },
+    required: ['from'],
+  },
+};
+
+export interface ProfileTarget {
+  station: Station;
+  account: string;
+  user: string;
+}
+
+export function profileTarget(a: Record<string, unknown>): ProfileTarget | { refused: string } {
+  const from = str(a.from);
+  if (!from) return { refused: 'get_profile requires `from`' };
+  const parsed = Line.parse(from);
+  const at = parsed?.path.indexOf('user') ?? -1;
+  if (parsed === null || at < 1 || at + 1 >= parsed.path.length) return { refused: `${from} is not a person: expected metro://<station>/<account>/user/<id>` };
+  const station = stationByName(parsed.station);
+  if (!station) return { refused: `no station named ${parsed.station}` };
+  if (station.readsProfiles !== true) return { refused: `${station.name} has no profile metro can read` };
+  return { station, account: parsed.path.slice(0, at).join('/'), user: parsed.path.slice(at + 1).join('/') };
+}
+
+export const profileScopeLine = (a: Record<string, unknown>): string | undefined => {
+  const target = profileTarget(a);
+  return 'refused' in target ? undefined : `metro://${target.station.name}/${target.account}/user/${target.user}`;
+};
+
+export async function dispatchGetProfile(a: Record<string, unknown>): Promise<ToolResult> {
+  const target = profileTarget(a);
+  if ('refused' in target) return errResult(target.refused);
+  try {
+    const { result } = await makeCtx(target.station.name).call('profile', { account: target.account, user: target.user });
+    return okJson(result);
+  } catch (e) {
+    return toErr('get_profile', e);
+  }
+}

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

@@ -0,0 +1,96 @@
+import type { ToolDef } from './tool-def.js';
+import type { CanonicalAttachment, Station, ToolResult } from '@metro-labs/core/stations/types';
+import { PROFILE_FIELDS, type ProfileField } from '@metro-labs/core/stations/profile';
+import { str } from '@metro-labs/core/str';
+import { STATIONS, stationByName } from '../stations/registry.js';
+import { cleanupAttachments, resolveAttachments, type ResolvedAttachment } from '../stations/attach-resolve.js';
+import { errResult, makeCtx, okJson, toErr } from './ctx.js';
+import { allowedAgents, currentIdentity } from './request-identity.js';
+
+const SOURCE = { type: 'string' };
+
+export const SET_PROFILE_TOOL: ToolDef = {
+  name: 'set_profile',
+  group: 'write',
+  description:
+    'Change how one of your accounts presents itself on its network: the display name, the bio ' +
+    '(about line) and the avatar. Args: station (required), account? (which account of that station; ' +
+    'needed only when you have several), name?, bio?, avatar? (an image given like an attachment: ' +
+    'exactly one of upload, url, path, data, plus mime and name). At least one of name, bio, avatar. ' +
+    'Each station takes what its network allows (`list_accounts` reports the fields under ' +
+    '`profiles`); a field the station cannot set is refused by name, never dropped. Discord changes ' +
+    'the bot username and app description (Discord allows two username changes an hour); Telegram ' +
+    'bots set their name, description and photo; a Telegram user account sets its first name, bio ' +
+    '(70 chars) and photo; WhatsApp sets the profile name, about and picture; XMTP writes the ' +
+    'name, description and avatar records of the account\'s <label>.stage.base.eth name on Base, ' +
+    'so it needs a name first (claimed on the channel page, never by you). Visible to everyone ' +
+    'who talks to the account, so do it when asked, not on your own. Returns {account, applied}.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      station: { type: 'string', description: 'discord-bot | telegram-bot | telegram | whatsapp | xmtp' },
+      account: { type: 'string', description: 'The account id on that station, from list_accounts.' },
+      name: { type: 'string', description: 'The display name.' },
+      bio: { type: 'string', description: 'The bio or about line.' },
+      avatar: {
+        type: 'object',
+        description: 'The new picture, as an attachment source.',
+        properties: { upload: SOURCE, url: SOURCE, path: SOURCE, data: SOURCE, mime: SOURCE, name: SOURCE },
+      },
+    },
+    required: ['station'],
+  },
+};
+
+export const profileCapabilities = (): Record<string, ProfileField[]> => {
+  const out: Record<string, ProfileField[]> = {};
+  for (const s of STATIONS) if (s.profileFields !== undefined) out[s.name] = [...s.profileFields];
+  return out;
+};
+
+const asked = (a: Record<string, unknown>): ProfileField[] => PROFILE_FIELDS.filter((f) => a[f] !== undefined);
+
+type Target = { station: Station } | { refused: string };
+
+function targetOf(a: Record<string, unknown>): Target {
+  const name = str(a.station);
+  if (!name) return { refused: 'set_profile requires `station`' };
+  const station = stationByName(name);
+  if (!station) return { refused: `no station named ${name}` };
+  const fields = station.profileFields;
+  if (fields === undefined) return { refused: `${name} accounts have no profile metro can set` };
+  const wanted = asked(a);
+  if (wanted.length === 0) return { refused: 'set_profile needs at least one of name, bio, avatar' };
+  const refused = wanted.filter((f) => !fields.has(f));
+  if (refused.length > 0) return { refused: `${name} cannot set ${refused.join(', ')}; it takes ${[...fields].join(', ')}` };
+  return { station };
+}
+
+function trainArgs(a: Record<string, unknown>, picture: ResolvedAttachment | undefined): Record<string, unknown> {
+  const args: Record<string, unknown> = {};
+  if (typeof a.account === 'string') args.account = a.account;
+  if (typeof a.name === 'string') args.name = a.name;
+  if (typeof a.bio === 'string') args.bio = a.bio;
+  if (picture !== undefined) args.avatar = { path: picture.path, mime: picture.mime, name: picture.name };
+  return args;
+}
+
+export async function dispatchSetProfile(a: Record<string, unknown>): Promise<ToolResult> {
+  const target = targetOf(a);
+  if ('refused' in target) return errResult(target.refused);
+  const avatar = a.avatar === undefined ? [] : [a.avatar as CanonicalAttachment];
+  let resolved: ResolvedAttachment[];
+  try {
+    resolved = await resolveAttachments(avatar, { allowed: allowedAgents(currentIdentity()) });
+  } catch (e) {
+    return toErr('set_profile', e);
+  }
+  try {
+    const { result } = await makeCtx(target.station.name).call('set_profile', trainArgs(a, resolved[0]));
+    return okJson(result);
+  } catch (e) {
+    return toErr('set_profile', e);
+  } finally {
+    await cleanupAttachments(resolved);
+  }
+}

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

@@ -0,0 +1,87 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { str } from '@metro-labs/core/str';
+import type { ReadFilter, Station, ToolResult } from '@metro-labs/core/stations/types';
+import { agentIdForAccount, accountFromLine, knownAccounts } from '../agents/map.js';
+import { attachmentUrl } from '../files/attach-serve.js';
+import { stationByName } from '../stations/registry.js';
+import { errResult, makeCtx, okJson, toErr } from './ctx.js';
+import { agentUser } from '../agent-user/user.js';
+
+const FILTERS: readonly (readonly [string, ReadFilter, string])[] = [
+  ['query', 'query', 'query'],
+  ['from', 'from', 'from'],
+  ['until', 'until', 'until'],
+  ['unread_only', 'unread_only', 'unreadOnly'],
+  ['message_id', 'message_id', 'messageId'],
+];
+
+const given = (v: unknown): boolean => v !== undefined && v !== null && v !== '' && v !== false;
+
+export function stationOfAccount(account: string): string | undefined {
+  const hits = knownAccounts().filter((a) => a.id === account);
+  return hits.length === 1 ? hits[0]?.station : undefined;
+}
+
+function readArgs(a: Record<string, unknown>): Record<string, unknown> {
+  const args: Record<string, unknown> = {};
+  if (str(a.line)) args.line = str(a.line);
+  if (str(a.account)) args.account = str(a.account);
+  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);
+  for (const [snake, , camel] of FILTERS)
+    if (given(a[snake])) args[camel] = typeof a[snake] === 'boolean' ? a[snake] : str(a[snake]);
+  return args;
+}
+
+function ignoredFilters(station: Station, a: Record<string, unknown>): string[] {
+  const supported = station.readFilters ?? new Set<ReadFilter>();
+  return FILTERS.filter(([snake, filter]) => given(a[snake]) && !supported.has(filter)).map(([snake]) => snake);
+}
+
+function withUrls(result: unknown, agentId: string | undefined): unknown {
+  if (agentId === undefined || !isRecord(result) || !isRecord(result.message)) return result;
+  const files = result.message.attachments;
+  if (!Array.isArray(files)) return result;
+  const attachments = files.map((f: unknown) => {
+    if (!isRecord(f) || typeof f.local_path !== 'string') return f;
+    const url = attachmentUrl(f.local_path, agentId);
+    const shown = agentUser() === null ? f : Object.fromEntries(Object.entries(f).filter(([key]) => key !== 'local_path'));
+    return url === null ? shown : { ...shown, url };
+  });
+  return { ...result, message: { ...result.message, attachments } };
+}
+
+function answer(result: unknown, ignored: string[]): unknown {
+  if (ignored.length === 0) return result;
+  return isRecord(result) && !Array.isArray(result) ? { ...result, ignored } : { result, ignored };
+}
+
+function accountOfCall(station: Station, a: Record<string, unknown>, result: unknown): string | undefined {
+  const named = str(a.account) || (isRecord(result) ? str(result.account) : '');
+  const account = named || accountFromLine(str(a.line))?.accountId;
+  return account === undefined ? undefined : agentIdForAccount(station.name, account);
+}
+
+export async function runRead(station: Station, a: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    const response = await makeCtx(station.name).call('read', readArgs(a));
+    const result = withUrls(response.result, accountOfCall(station, a, response.result));
+    return okJson(answer(result, ignoredFilters(station, a)));
+  } catch (e) {
+    return toErr('read', e);
+  }
+}
+
+export function linelessRead(a: Record<string, unknown>): Promise<ToolResult> | ToolResult {
+  const account = str(a.account);
+  if (!account) return errResult('read requires `line` or `account`');
+  const name = stationOfAccount(account);
+  const station = name === undefined ? undefined : stationByName(name);
+  if (station === undefined) return errResult(`no account ${account} on this box; list_accounts names them`);
+  if (!station.messageVerbs.has('read'))
+    return errResult(`${station.name} does not support read; it supports ${[...station.messageVerbs].join(', ')}.`);
+  if (!station.readFilters?.has('account'))
+    return errResult(`${station.name} reads one conversation at a time; give a \`line\` instead of an account`);
+  return runRead(station, a);
+}

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

@@ -0,0 +1,46 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { IncomingMessage } from 'node: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 {
+  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/session-slot.ts

@@ -0,0 +1,48 @@
+import { randomUUID } from 'node:crypto';
+import { currentBusSeq } from '@metro-labs/core/events';
+import { newReplayLedger } from '../channels/relay.js';
+import { McpSession, channelLog } from './session.js';
+import { allowedAgents, type RequestIdentity } from './request-identity.js';
+
+export class SessionSlot {
+  private session: McpSession | undefined;
+  private readonly ledger = newReplayLedger();
+  private started = false;
+
+  get current(): McpSession | undefined {
+    return this.session;
+  }
+
+  startInbound(): void {
+    if (this.started) return;
+    this.started = true;
+    if (this.ledger.startAt < 0) this.ledger.startAt = currentBusSeq();
+    this.session?.startChannel();
+  }
+
+  async open(
+    identity: RequestIdentity,
+    adoptId?: string,
+  ): Promise<McpSession> {
+    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,
+      onClosed: (s) => {
+        if (this.session === s) this.session = undefined;
+      },
+    });
+    this.session = session;
+    if (this.started) session.startChannel();
+    channelLog('session: opened', 'id', id, 'adopted', adoptId !== undefined);
+    return session;
+  }
+
+  async close(): Promise<void> {
+    await this.session?.close();
+  }
+}

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

@@ -1,20 +1,17 @@
 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 { 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';
 
 export const channelLog = (...a: unknown[]): void => {
   console.error('[metro-mcp]', ...a);
@@ -22,10 +19,15 @@ 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;
+
+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,
@@ -47,7 +49,7 @@ function makeTransport(
 
 export interface SessionInit {
   id: string;
-  scopeKey: string;
+  scope: Set<string>;
   adopted: boolean;
   ledger: ReplayLedger;
   onClosed: (session: McpSession) => void;
@@ -55,14 +57,12 @@ export interface SessionInit {
 
 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();
   private sink: RawGetSink | undefined;
   private unsubscribe: (() => void) | undefined;
   private closed = false;
@@ -72,12 +72,10 @@ export class McpSession {
 
   private constructor(init: SessionInit) {
     this.id = init.id;
-    this.scopeKey = init.scopeKey;
+    this.scope = init.scope;
     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' },
@@ -99,23 +97,29 @@ 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,
+      answerPermission,
     });
     registerPermissionRelay({
       mcp: this.server,
       relay: this.relay,
-      owner: this.owner,
+      inScope: (line) => this.inScope(line),
       log: channelLog,
     });
     this.channel = new ChannelRelay({
       relay: this.relay,
       log: channelLog,
-      inScope: (line) => this.owner.inScope(line),
+      inScope: (line) => this.inScope(line),
       ledger: init.ledger,
     });
   }
@@ -139,22 +143,17 @@ export class McpSession {
     return this.sink;
   }
 
-  touch(): void {
-    this.lastSeenAt = Date.now();
+  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 {
+  bindSink(sink: RawGetSink | undefined): void {
     this.sink = sink;
-    if (sink === undefined) {
-      this.owner.releaseStream();
-      return;
-    }
-    this.owner.bindStream(identity);
-    this.announceToolSchema();
+    if (sink !== undefined) this.announceToolSchema();
   }
 
   private get schemaNoticeDue(): boolean {
@@ -172,15 +171,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();
@@ -195,7 +186,6 @@ export class McpSession {
   dropStream(): void {
     const sink = this.sink;
     this.sink = undefined;
-    this.owner.releaseStream();
     sink?.close();
   }
 
@@ -203,6 +193,7 @@ export class McpSession {
     if (this.closed) return;
     this.closed = true;
     this.onClosed(this);
+    forgetPromptsOf(this.server);
     this.dropStream();
     this.unsubscribe?.();
     this.unsubscribe = undefined;

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

@@ -0,0 +1,88 @@
+import type { GroupOp, Station, StationTool, ToolGroup } from '@metro-labs/core/stations/types';
+import { STATIONS } from '../stations/registry.js';
+import { COMMON_TOOLS, LIST_ACCOUNTS_TOOL } from './tool-schemas.js';
+import { SET_PROFILE_TOOL } from './profile-tool.js';
+import { GET_PROFILE_TOOL } from './profile-lookup.js';
+import type { ToolDef } from './tool-def.js';
+
+const defOf = (tool: StationTool): ToolDef => ({
+  name: tool.name,
+  description: tool.description,
+  inputSchema: tool.inputSchema,
+  ...(tool.group === undefined ? {} : { group: tool.group }),
+  ...(tool.destructive === true ? { destructive: true } : {}),
+});
+
+export const TOOL_DEFS: ToolDef[] = [
+  ...COMMON_TOOLS,
+  ...STATIONS.flatMap((s) => s.tools.map(defOf)),
+  LIST_ACCOUNTS_TOOL,
+  SET_PROFILE_TOOL,
+  GET_PROFILE_TOOL,
+];
+
+const BY_NAME = new Map(TOOL_DEFS.map((d) => [d.name, d] as const));
+
+export const declaredGroup = (name: string): ToolGroup | undefined => BY_NAME.get(name)?.group;
+
+export const toolGroupOf = (name: string): ToolGroup => declaredGroup(name) ?? 'write';
+
+export interface ToolAnnotations {
+  readOnlyHint: boolean;
+  destructiveHint?: boolean;
+}
+
+export interface PublishedTool {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  annotations: ToolAnnotations;
+}
+
+const annotationsOf = (def: ToolDef): ToolAnnotations =>
+  toolGroupOf(def.name) === 'read'
+    ? { readOnlyHint: true }
+    : { readOnlyHint: false, destructiveHint: def.destructive === true };
+
+export const listedTools = (): PublishedTool[] =>
+  TOOL_DEFS.map((def) => ({
+    name: def.name,
+    description: def.description,
+    inputSchema: def.inputSchema,
+    annotations: annotationsOf(def),
+  }));
+
+const STATION_OF_TOOL = new Map(STATIONS.flatMap((s) => s.tools.map((t) => [t.name, s.name] as const)));
+
+export const stationToolOwners = (): Record<string, string> => Object.fromEntries(STATION_OF_TOOL);
+
+export function stationForTool(name: string, args: Record<string, unknown>): string | undefined {
+  if (name === 'create_group' || name === 'set_profile')
+    return typeof args.station === 'string' && args.station !== '' ? args.station : undefined;
+  return STATION_OF_TOOL.get(name);
+}
+
+const GROUP_OP_TOOLS: Record<GroupOp, string> = {
+  create_group: 'create_group',
+  add_members: 'add_members',
+  remove_members: 'remove_members',
+  invite_link: 'export_invite',
+};
+
+export interface GroupedTool {
+  name: string;
+  group: ToolGroup;
+}
+
+export const stationToolGroups = (): Record<string, GroupedTool[]> =>
+  Object.fromEntries(STATIONS.filter((s) => s.hasAccounts).map((s) => [s.name, channelToolsOf(s)]));
+
+export function channelToolsOf(station: Station): GroupedTool[] {
+  const names: string[] = [...station.messageVerbs];
+  if (station.hasTrain && station.hasAccounts) names.push('list_members');
+  for (const op of station.groupOps ?? []) names.push(GROUP_OP_TOOLS[op]);
+  if ((station.profileFields?.size ?? 0) > 0) names.push('set_profile');
+  if (station.readsProfiles === true) names.push('get_profile');
+  names.push(...station.tools.map((t) => t.name));
+  return names.map((name) => ({ name, group: toolGroupOf(name) }));
+}

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

@@ -0,0 +1,9 @@
+import type { ToolGroup } from '@metro-labs/core/stations/types';
+
+export interface ToolDef {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  group?: ToolGroup;
+  destructive?: boolean;
+}