@stage-labs/metro 0.1.0-beta.23 → 0.1.0-beta.231

package/runtime/node_modules/@metro-labs/telegram/src/format.ts

@@ -1,7 +1,6 @@
 import type { Chat, Message, Peer, User } from '@mtcute/bun';
-import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
 import { lineOf } from './accounts.js';
-import { mintId } from './wire.js';
+import { mintId } from '@metro-labs/core/stations/station-runtime';
 import { isDownloadable, pendingDescriptorOf } from './attachments.js';
 
 const isUser = (peer: Peer): peer is User => peer.type === 'user';
@@ -13,8 +12,9 @@ export function senderName(peer: Peer): string | undefined {
 }
 
 export function displayName(peer: Peer): string | undefined {
-  if (isUser(peer)) return peer.firstName;
-  return peer.title;
+  if (!isUser(peer)) return peer.title;
+  const name = [peer.firstName, peer.lastName].filter((part) => typeof part === 'string' && part !== '').join(' ');
+  return name === '' ? undefined : name;
 }
 
 function chatName(peer: Peer): string | undefined {
@@ -45,6 +45,20 @@ export function isOwnEcho(m: Message): boolean {
   return isUser(sender) && sender.isSelf;
 }
 
+function replyMeta(m: Message): Record<string, unknown> {
+  const replied = m.replyToMessage;
+  const target = replied?.id;
+  if (replied === null || typeof target !== 'number') return {};
+  if (m.isTopicMessage && target === replied.threadId) return {};
+  const id = String(target);
+  const sender = replied.sender;
+  return {
+    reply_to: id,
+    event: { type: 'reply', replyTo: id },
+    reply_to_self: sender?.type === 'user' && sender.isSelf,
+  };
+}
+
 export function envelope(
   accountId: string,
   m: Message,
@@ -58,7 +72,6 @@ export function envelope(
       ? [pendingDescriptorOf(media)]
       : undefined;
   return {
-    kind: 'inbound',
     id: mintId(),
     ts: m.date.toISOString(),
     station: 'telegram',
@@ -71,6 +84,7 @@ export function envelope(
     text: projectText(m),
     is_private: isPrivate,
     has_media: media !== null,
+    ...replyMeta(m),
     payload: {
       account: accountId,
       message_id: String(m.id),
@@ -79,34 +93,6 @@ export function envelope(
   };
 }
 
-export function attachmentSavedEnvelope(
-  accountId: string,
-  line: string,
-  sourceEnvId: string,
-  saved: SavedAttachment,
-  index = 0,
-): Record<string, unknown> {
-  return {
-    kind: 'inbound',
-    id: mintId(),
-    ts: new Date().toISOString(),
-    station: 'telegram',
-    line,
-    from: `metro://telegram/${accountId}/self`,
-    text: `📎 saved: ${saved.path}`,
-    payload: {
-      account: accountId,
-      contentType: 'attachmentSaved',
-      attachmentFor: sourceEnvId,
-      index,
-      attachmentPath: saved.path,
-      localPath: saved.path,
-      mime: saved.mime,
-      name: saved.name,
-    },
-  };
-}
-
 export interface ReactionInput {
   accountId: string;
   chatId: number;
@@ -121,7 +107,6 @@ export interface ReactionInput {
 
 export function reactionEnvelope(r: ReactionInput): Record<string, unknown> {
   return {
-    kind: 'react',
     id: mintId(),
     ts: r.date.toISOString(),
     station: 'telegram',

package/runtime/node_modules/@metro-labs/telegram/src/group.ts

@@ -1,9 +1,9 @@
 import type {
   GroupResult,
   MemberOutcome,
-} from '@metro-labs/mcp/stations/types';
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { errMsg } from '@metro-labs/mcp/log';
+} from '@metro-labs/core/stations/types';
+import { TrainError } from '@metro-labs/core/train-error';
+import { errMsg } from '@metro-labs/core/log';
 import type { UserClient } from './client.js';
 import { lineOf } from './accounts.js';
 

package/runtime/node_modules/@metro-labs/telegram/src/inbound.ts

@@ -1,36 +1,12 @@
 import type { Message } from '@mtcute/bun';
-import { errMsg, log } from '@metro-labs/mcp/log';
-import { emit } from './wire.js';
-import { envelope, isOwnEcho, attachmentSavedEnvelope } from './format.js';
+import { errMsg, log } from '@metro-labs/core/log';
+import { emit } from '@metro-labs/core/stations/station-runtime';
+import { reportAttachment } from '@metro-labs/core/stations/train-events';
+import { envelope, isOwnEcho } from './format.js';
 import { downloadMedia, isDownloadable } from './attachments.js';
 import { subscribeReactions } from './reactions.js';
 import type { UserClient } from './client.js';
 
-async function saveMediaAndEmit(
-  client: UserClient,
-  m: Message,
-  env: Record<string, unknown>,
-): Promise<void> {
-  const { media } = m;
-  if (media === null || !isDownloadable(media)) return;
-  const accountId = client.account.id;
-  try {
-    const saved = await downloadMedia(client, media, String(m.id), 0);
-    emit(
-      attachmentSavedEnvelope(
-        accountId,
-        env.line as string,
-        env.id as string,
-        saved,
-      ),
-    );
-  } catch (e) {
-    process.stderr.write(
-      `telegram[${accountId}] media save failed: ${errMsg(e)}\n`,
-    );
-  }
-}
-
 function emitMessage(client: UserClient, m: Message): void {
   log.debug(
     { train: 'telegram', account: client.account.id, messageId: m.id },
@@ -39,12 +15,15 @@ function emitMessage(client: UserClient, m: Message): void {
   if (isOwnEcho(m)) return;
   const env = envelope(client.account.id, m);
   emit(env);
-  if (m.media !== null)
-    saveMediaAndEmit(client, m, env).catch((err: unknown) => {
-      process.stderr.write(
-        `telegram[${client.account.id}] media save failed: ${errMsg(err)}\n`,
-      );
-    });
+  const { media } = m;
+  if (media === null || !isDownloadable(media)) return;
+  reportAttachment(downloadMedia(client, media, String(m.id), 0), {
+    station: 'telegram',
+    account: client.account.id,
+    line: String(env.line),
+    forId: String(env.id),
+    index: 0,
+  });
 }
 
 function subscribe(client: UserClient): void {

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

@@ -1,46 +1,7 @@
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { errMsg } from '@metro-labs/mcp/log';
-import { readCalls } from '@metro-labs/mcp/trains/protocol';
-import {
-  accounts,
-  loadAccounts,
-  accountFor,
-  lineOf,
-  targetOf,
-} from './accounts.js';
-import { createClient, type UserClient } from './client.js';
+import { runClientTrain } from '@metro-labs/core/stations/train-boot';
+import { accounts, loadAccounts } from './accounts.js';
+import { createClient } from './client.js';
 import { startInbound } from './inbound.js';
 import { makeHandleCall } from './actions.js';
 
-const clients = new Map<string, UserClient>();
-
-function clientFor(accountId: string): UserClient {
-  let client = clients.get(accountId);
-  if (!client) {
-    const account = accounts.get(accountId);
-    if (!account)
-      throw new TrainError('not_implemented', `unknown account '${accountId}'`);
-    client = createClient(account);
-    clients.set(accountId, client);
-  }
-  return client;
-}
-
-const handleCall = makeHandleCall(clientFor);
-
-readCalls('telegram', handleCall);
-
-function boot(): void {
-  for (const cfg of loadAccounts()) accounts.set(cfg.id, cfg);
-  for (const id of accounts.keys())
-    startInbound(clientFor(id)).catch((err: unknown) => {
-      process.stderr.write(`telegram[${id}] inbound failed: ${errMsg(err)}\n`);
-    });
-  process.stderr.write(
-    `telegram train ready (inbound+outbound) — ${accounts.size} account(s): ${[...accounts.keys()].join(', ')}\n`,
-  );
-}
-
-boot();
-
-export { clients, accounts, clientFor, accountFor, lineOf, targetOf };
+runClientTrain({ station: 'telegram', accounts, loadAccounts, createClient, startInbound, makeHandleCall });

package/runtime/node_modules/@metro-labs/telegram/src/media-actions.ts

@@ -1,17 +1,16 @@
 import type { InputMediaLike, Message } from '@mtcute/bun';
 import { InputMedia } from '@mtcute/bun';
-import { isImageMime, isImageExt } from '@metro-labs/mcp/stations/attachments';
+import { isImageMime, isImageExt } from '@metro-labs/core/stations/attachments';
 import type { UserClient } from './client.js';
 
 export interface CanonicalAttachment {
   kind?: string;
   path?: string;
-  url?: string;
   mime?: string;
   name?: string;
 }
 
-const srcOf = (att: CanonicalAttachment): string => att.path ?? att.url ?? '';
+const srcOf = (att: CanonicalAttachment): string => att.path ?? '';
 
 function isImage(att: CanonicalAttachment): boolean {
   if (att.kind === 'image') return true;

package/runtime/node_modules/@metro-labs/telegram/src/members.ts

@@ -1,4 +1,4 @@
-import type { MemberList, MetroMember } from '@metro-labs/mcp/stations/types';
+import type { MemberList, MetroMember } from '@metro-labs/core/stations/types';
 import type { UserClient } from './client.js';
 
 export interface RawUserMember {

package/runtime/node_modules/@metro-labs/telegram/src/profile.ts

@@ -0,0 +1,70 @@
+import type { TelegramClient } from '@mtcute/bun';
+import {
+  assertImage,
+  fieldsOf,
+  parseProfileChange,
+  type ProfileApplied,
+  type ProfileChange,
+} from '@metro-labs/core/stations/profile';
+import { respond, type StationHandler } from '@metro-labs/core/stations/station-runtime';
+import { str } from '@metro-labs/core/str';
+import { makeProfileCache, nonEmpty, type ProfileCache, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accountFor } from './accounts.js';
+import type { UserClient } from './client.js';
+
+const BIO_MAX = 70;
+
+export async function applyProfile(tg: TelegramClient, change: ProfileChange): Promise<void> {
+  if (change.name !== undefined || change.bio !== undefined)
+    await tg.updateProfile({
+      ...(change.name === undefined ? {} : { firstName: change.name }),
+      ...(change.bio === undefined ? {} : { bio: change.bio.slice(0, BIO_MAX) }),
+    });
+  if (change.avatar !== undefined) {
+    assertImage(change.avatar);
+    await tg.setMyProfilePhoto({ type: 'photo', media: `file:${change.avatar.path}` });
+  }
+}
+
+export function makeSetProfile(clientFor: (accountId: string) => UserClient): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const change = parseProfileChange(args);
+    await applyProfile(clientFor(accountId).tg, change);
+    const result: ProfileApplied = { account: accountId, applied: fieldsOf(change) };
+    respond(id, { result });
+  };
+}
+
+const senders = new Map<string, ProfileCache<SenderProfile>>();
+
+function sendersOf(client: UserClient): ProfileCache<SenderProfile> {
+  const held = senders.get(client.account.id);
+  if (held !== undefined) return held;
+  const made = makeProfileCache<SenderProfile>(
+    async (user) => {
+      const full = await client.tg.getFullUser(Number(user));
+      const handle = nonEmpty(full.username);
+      const display = nonEmpty([full.firstName, full.lastName].filter((part) => typeof part === 'string').join(' '));
+      return {
+        id: user,
+        ...(handle === undefined ? {} : { name: `@${handle}` }),
+        ...(display === undefined ? {} : { display_name: display }),
+        ...(nonEmpty(full.bio) === undefined ? {} : { about: nonEmpty(full.bio) }),
+      };
+    },
+    { onError: (user, err) => process.stderr.write(`telegram[${client.account.id}] could not read the profile of ${user}: ${err instanceof Error ? err.message : String(err)}\n`) },
+  );
+  senders.set(client.account.id, made);
+  return made;
+}
+
+export function makeReadProfile(clientFor: (accountId: string) => UserClient): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const user = str(args.user) ?? '';
+    if (!/^\d+$/.test(user)) throw new TrainError('telegram_user_required', 'profile needs the numeric Telegram id of the person', { retryable: false });
+    respond(id, { result: (await sendersOf(clientFor(accountId)).get(user)) ?? { id: user } });
+  };
+}

package/runtime/node_modules/@metro-labs/telegram/src/reactions.ts

@@ -1,7 +1,7 @@
 import type { tl } from '@mtcute/bun';
 import { getBarePeerId, getMarkedPeerId } from '@mtcute/bun';
-import { errMsg } from '@metro-labs/mcp/log';
-import { emit } from './wire.js';
+import { errMsg } from '@metro-labs/core/log';
+import { emit } from '@metro-labs/core/stations/station-runtime';
 import { reactionEnvelope } from './format.js';
 import type { UserClient } from './client.js';
 

package/runtime/node_modules/@metro-labs/telegram/src/station.ts

@@ -1,4 +1,5 @@
-import type { GroupOp, Station, Verb } from '@metro-labs/mcp/stations/types';
+import type { GroupOp, Station, Verb } from '@metro-labs/core/stations/types';
+import { PROFILE_FIELDS, type ProfileField } from '@metro-labs/core/stations/profile';
 
 export const telegramStation: Station = {
   name: 'telegram',
@@ -20,5 +21,7 @@ export const telegramStation: Station = {
     'invite_link',
   ]),
   attachmentMode: 'canonical',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
   tools: [],
 };

package/runtime/node_modules/@metro-labs/telegram/src/types.ts

@@ -3,5 +3,4 @@ export interface UserAccount {
   session: string;
   apiId?: number;
   apiHash?: string;
-  owner?: string;
 }

package/runtime/node_modules/@metro-labs/telegram-bot/package.json

@@ -13,7 +13,7 @@
     "test": "tsc --noEmit && bun test test/"
   },
   "dependencies": {
-    "@metro-labs/mcp": "workspace:*"
+    "@metro-labs/core": "workspace:*"
   },
   "devDependencies": {
     "@stage-labs/config": "0.1.0-beta.2",

package/runtime/node_modules/@metro-labs/telegram-bot/src/accounts.ts

@@ -1,38 +1,25 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
 import {
   makeAccountStore,
   resolveAccountId,
-} from '@metro-labs/mcp/stations/account-store';
-import { Line } from '@metro-labs/mcp/lines';
-
-const ACCOUNTS_FILE =
-  process.env.TELEGRAM_BOT_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'telegram-bot-accounts.json');
+} from '@metro-labs/core/stations/account-store';
+import { Line } from '@metro-labs/core/lines';
 
 export interface AccountConfig {
   id: string;
   token: string;
-  owner?: string;
 }
 
 export const { loadAccounts } = makeAccountStore<AccountConfig>({
   prefix: 'telegram-bot',
-  file: ACCOUNTS_FILE,
-  allowlistEnv: ['TELEGRAM_BOT_ONLY_ACCOUNTS', 'TELEGRAM_BOT_ACCOUNTS'],
   validate(raw, die) {
-    const seenId = new Set<string>();
     const seenTok = new Set<string>();
     for (const a of raw) {
-      if (!a.id) die('account missing id');
       if (!a.token || typeof a.token !== 'string')
         die(`account '${a.id}' missing token`);
-      if (seenId.has(a.id)) die(`duplicate account id '${a.id}'`);
       if (seenTok.has(a.token))
         die(
           `account '${a.id}' reuses a token used by another account (409 on getUpdates)`,
         );
-      seenId.add(a.id);
       seenTok.add(a.token);
     }
   },
@@ -43,6 +30,7 @@ export interface Account {
   api: string;
   fileApi: string;
   offset: number;
+  username?: string;
 }
 export const accounts = new Map<string, Account>();
 
@@ -50,37 +38,15 @@ export async function tg<T>(
   accountId: string,
   method: string,
   body: unknown,
-  timeoutMs = 30_000,
-): Promise<T> {
-  const acct = accounts.get(accountId);
-  if (!acct) throw new Error(`unknown account '${accountId}'`);
-  const res = await fetch(`${acct.api}/${method}`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(timeoutMs),
-  });
-  const json = (await res.json()) as {
-    ok: boolean;
-    description?: string;
-    result?: T;
-  };
-  if (!json.ok)
-    throw new Error(`telegram-bot ${method}: ${json.description ?? 'unknown'}`);
-  return json.result as T;
-}
-
-export async function tgForm<T>(
-  accountId: string,
-  method: string,
-  form: FormData,
-  timeoutMs = 60_000,
+  timeoutMs = body instanceof FormData ? 60_000 : 30_000,
 ): Promise<T> {
   const acct = accounts.get(accountId);
   if (!acct) throw new Error(`unknown account '${accountId}'`);
+  const form = body instanceof FormData;
   const res = await fetch(`${acct.api}/${method}`, {
     method: 'POST',
-    body: form,
+    ...(form ? {} : { headers: { 'Content-Type': 'application/json' } }),
+    body: form ? body : JSON.stringify(body),
     signal: AbortSignal.timeout(timeoutMs),
   });
   const json = (await res.json()) as {

package/runtime/node_modules/@metro-labs/telegram-bot/src/actions.ts

@@ -1,31 +1,20 @@
-import { accountFor, accounts, tg, targetOf } from './accounts.js';
-import { respond } from './wire.js';
-import { errMsg } from '@metro-labs/mcp/log';
-import { normalizeTelegram } from '@metro-labs/mcp/stations/messaging-normalize';
+import { accounts, tg, targetOf } from './accounts.js';
+import { errMsg } from '@metro-labs/core/log';
+import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
 import {
   adminMemberList,
   inaccessibleMemberList,
   type TgChatMember,
 } from './members.js';
-import {
-  makeStation,
-  type CallMsg,
-  type StationHandler,
-} from '@metro-labs/mcp/stations/station-runtime';
+import { makeStation, respond, type CallMsg, type StationHandler } from '@metro-labs/core/stations/station-runtime';
 import { mediaKindOf } from './attachments.js';
-import { assertContentLength } from '@metro-labs/mcp/stations/attachments';
 import {
   emitOutbound,
   finishSend,
-  media,
   MEDIA_METHOD_FIELD,
-  sendDice,
-  sendLocation,
   sendMedia,
 } from './media-actions.js';
-
-
-
+import { readProfile, setProfile } from './profile.js';
 
 export type { CallMsg };
 
@@ -59,7 +48,6 @@ async function listAccounts(id: string): Promise<void> {
         id: a.cfg.id,
         handle: username === null ? null : `@${username}`,
         url: username === null ? null : `https://t.me/${username}`,
-        owner: a.cfg.owner ?? null,
         botId: me?.id ?? null,
         username,
       };
@@ -72,13 +60,10 @@ interface SendArgs {
   line: string;
   text: string;
   replyTo?: string;
-  parseMode?: string;
-  buttons?: { text: string; url: string }[][];
   account?: string;
   attachments?: {
     kind?: string;
     path?: string;
-    url?: string;
     mime?: string;
     name?: string;
   }[];
@@ -87,11 +72,8 @@ interface SendArgs {
 
 type WireAttachment = NonNullable<SendArgs['attachments']>[number];
 
-const attachmentSrc = (att: WireAttachment): string | undefined =>
-  att.path ?? att.url;
-
 const attachmentKind = (att: WireAttachment): string =>
-  mediaKindOf(att.kind, att.mime, attachmentSrc(att) ?? att.name);
+  mediaKindOf(att.kind, att.mime, att.path ?? att.name);
 
 async function sendOneAttachment(
   a: SendArgs,
@@ -103,10 +85,9 @@ async function sendOneAttachment(
   if (!mf) throw new Error(`telegram-bot cannot send a '${kind}' attachment`);
   const sent = await sendMedia(mf.method, mf.field, {
     line: a.line,
-    path: attachmentSrc(att),
+    path: att.path,
     caption,
     replyTo: a.replyTo,
-    parseMode: a.parseMode,
     account: a.account,
     name: att.name,
   });
@@ -151,13 +132,11 @@ async function send(id: string, args: Record<string, unknown>): Promise<void> {
     await sendAttachments(id, a);
     return;
   }
-  const { line, text, replyTo, parseMode, buttons, account } = a;
+  const { line, text, replyTo, account } = a;
   const { accountId, chatId, topicId } = targetOf(line, account);
   const body: Record<string, unknown> = { chat_id: chatId, text };
   if (topicId !== undefined) body.message_thread_id = topicId;
   if (replyTo) body.reply_parameters = { message_id: Number(replyTo) };
-  if (parseMode) body.parse_mode = parseMode;
-  if (buttons) body.reply_markup = { inline_keyboard: buttons };
   const sent = await tg<{ message_id: number }>(accountId, 'sendMessage', body);
   finishSend(id, accountId, line, String(sent.message_id), text, replyTo);
 }
@@ -178,12 +157,20 @@ async function react(id: string, args: Record<string, unknown>): Promise<void> {
   respond(id, { result: { ok: true, account: accountId } });
 }
 
+async function typing(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, account } = args as { line: string; account?: string };
+  const { accountId, chatId, topicId } = targetOf(line, account);
+  const body: Record<string, unknown> = { chat_id: chatId, action: 'typing' };
+  if (topicId !== undefined) body.message_thread_id = topicId;
+  await tg(accountId, 'sendChatAction', body);
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
 async function edit(id: string, args: Record<string, unknown>): Promise<void> {
-  const { line, messageId, text, parseMode, account } = args as {
+  const { line, messageId, text, account } = args as {
     line: string;
     messageId: string;
     text: string;
-    parseMode?: string;
     account?: string;
   };
   const { accountId, chatId } = targetOf(line, account);
@@ -191,7 +178,6 @@ async function edit(id: string, args: Record<string, unknown>): Promise<void> {
     chat_id: chatId,
     message_id: Number(messageId),
     text,
-    parse_mode: parseMode,
   });
   respond(id, { result: { ok: true, account: accountId } });
 }
@@ -210,34 +196,6 @@ async function remove(id: string, args: Record<string, unknown>): Promise<void>
   respond(id, { result: { ok: true, account: accountId } });
 }
 
-
-
-async function download(id: string, args: Record<string, unknown>): Promise<void> {
-  const {
-    fileId,
-    outDir = '/tmp',
-    account,
-  } = args as { fileId: string; outDir?: string; account?: string };
-  const accountId = accountFor({ account });
-  const acct = accounts.get(accountId);
-  if (!acct) throw new Error(`unknown account '${accountId}'`);
-  const meta = await tg<{ file_path: string }>(accountId, 'getFile', {
-    file_id: fileId,
-  });
-  const res = await fetch(`${acct.fileApi}/${meta.file_path}`, {
-    signal: AbortSignal.timeout(60_000),
-  });
-  if (!res.ok) throw new Error(`telegram-bot download ${res.status}`);
-  assertContentLength(res.headers.get('content-length'));
-  const data = await res.arrayBuffer();
-  const filename = meta.file_path.split('/').pop() ?? `${fileId}.bin`;
-  const path = `${outDir}/${Date.now()}-${filename}`;
-  await Bun.write(path, data);
-  respond(id, {
-    result: { path, fileSize: data.byteLength, account: accountId },
-  });
-}
-
 async function listMembers(
   id: string,
   args: Record<string, unknown>,
@@ -268,28 +226,15 @@ const HANDLERS: Record<string, StationHandler> = {
   accounts: (id) => listAccounts(id),
   send,
   react,
+  typing,
   edit,
   delete: remove,
   listMembers,
-  send_photo: (id, args) =>
-    media(id, 'sendPhoto', 'photo', ((args.caption as string) ?? '') + ' [image]', args),
-  send_document: (id, args) =>
-    media(id, 'sendDocument', 'document', ((args.caption as string) ?? '') + ' [file]', args),
-  send_voice: (id, args) => media(id, 'sendVoice', 'voice', '[voice]', args),
-  send_sticker: (id, args) => media(id, 'sendSticker', 'sticker', '[sticker]', args),
-  send_dice: sendDice,
-  send_location: sendLocation,
-  download,
+  set_profile: setProfile,
+  profile: readProfile,
 };
 
 export const handleCall = makeStation({
   handlers: HANDLERS,
-  normalize: normalizeTelegram,
-  preDispatch: (id, action) => {
-    if (action === 'read') {
-      respond(id, { error: "unsupported verb 'read' on telegram-bot" });
-      return true;
-    }
-    return false;
-  },
+  normalize: messagingAliases(),
 });

package/runtime/node_modules/@metro-labs/telegram-bot/src/attachments.ts

@@ -1,8 +1,8 @@
 import {
   saveBufferToCache,
   assertContentLength,
-} from '@metro-labs/mcp/stations/attachments';
-import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
+} from '@metro-labs/core/stations/attachments';
+import type { SavedAttachment } from '@metro-labs/core/stations/attachments';
 import { tg, accounts } from './accounts.js';
 import type { TgMsg } from './types.js';